Függvények, eljárások

 

Abs

Visszatérési értéke, az argumentummal azonos típusú,  az argumentum abszolút értéke.

Declarációja:
function Abs(X: Real): <A paraméterrel azonos típus>;

Példa:
var
  r: Real;
  i: Integer;
begin
  r := Abs(-2.3);       { 2.3 }
  i := Abs(-157);       { 157 }
end.

ArcTan

Visszatérési értéke az argumentum arkusz tangense.

Declarációja:
function ArcTan(X: Real): Real;

Megjegyzés:
A visszatérési érték radiánban értendő.

Lásd még:
Cos
Sin

Példa:
var R: Real;
begin
  Writeln( arctan(1) );
  Writeln( pi / 4 );
  Readln
end.

Cos

Visszatérési értéke az argumentum koszinusza.

Declarációja:
function Cos(X: Real): Real;

Megjegyzés:
Az X szög radiánban értendő.

Lásd még:
ArcTan
Sin

Példa:
var
  R: Real;
begin
  R := Cos(Pi);
  Writeln ('Pi koszinusza: ', R);
  Readln;
end.

Dec

Egy változót csökkent.

Declarációja:
Procedure Dec(var X [; N: Longint]);

Megjegyzés:
Az X,  sorszámozott típusú változó, értékét N-el csökkenti. Ha N elmarad, akkor eggyel csökkent.
Hatása megegyezik az X := X - N illetve az X := X - 1 utasításokkal.

Lásd még:
Inc
Pred
Succ

Példa:
var
  IntVar: Integer;
  LongintVar: Longint;
begin
  Intvar := 10;
  LongintVar := 10;
  Dec(IntVar);   { IntVar := IntVar - 1 }
  Dec(LongintVar, 5);  { LongintVar := LongintVar - 5 }
end.

Exp

Visszatérési értéke: ex, ahol e a természetes logaritmus alapja.

Declarációja:
function Exp(X: Real): Real;

Lásd még:
Ln

Példa:
 begin
   Writeln('e = ', Exp(1.0));
 end.

Frac

Visszatérési értéke az argumentum törtrésze.

Declarációja:
function Frac(X: Real): Real;

Lásd még:
Int

Példa:
var
  R: Real;
begin
  R := Frac(123.456);    { 0.456 }
  R := Frac(-123.456);   { -0.456 }
end.

Inc

Egy változót növel.

Declarációja:
Procedure Inc(var X [; N: Longint]);

Megjegyzés:
Az X,  sorszámozott típusú változó, értékét N-el növeli. Ha N elmarad, akkor eggyel növel. Hatása megegyezik az X := X + N illetve az X := X + 1 utasításokkal.

Lásd még:
Dec
Pred
Succ

Példa:
var
  IntVar: Integer;
  LongintVar: Longint;
begin
  Inc(IntVar);  { IntVar := IntVar + 1 }
  Inc(LongintVar, 5); { LongintVar := LongintVar + 5 }
end. 

Int

Visszatérési értéke az argumentum egészrésze.

Declarációja:
function Int(X: Real): Real;

Lásd még:
Frac
Round
Trunc

Példa:
var R: Real;
begin
  R := Int(123.456);    { 123.0 }
  R := Int(-123.456);   { -123.0 }
end.

Ln

Visszatérési értéke az argumentum természetes alapú logaritmusa.

Declarációja:
function Ln(X: Real): Real;

Lásd még:
Exp

Példa:
var
   e : real;
 begin
   e := Exp(1.0);
   Writeln('ln(e) = ', ln(e));
 end.

Ord

Egy sorszámozott típusú kifejezés sorszámával tér vissza.

Declarációja:
function Ord(X): Longint;

Megjegyzés:
X egy sorszámozott típusú kifejezés.

Lásd még:
Chr

Példa:
type
   Colors = (PIROS, KEK, ZOLD);       {ld. felsorolt típus}
 begin
   Writeln('KEK sorszáma: ', Ord(KEK));
   Writeln('A "c" karakter ASCII kódja: ', Ord('c'));
 end.

Pi

A pi értékével tér vissza.

Declarációja:
function Pi: Real;

Példa:
begin
   Writeln('Pi = ', Pi);
 end.

Pred

A paraméterét megelőző értéket adja vissza.

Declarációja:
function Pred(X): <A paraméterrel azonos típus>;

Megjegyzés:
X egy sorszámozott típusú kifejezés.

Lásd még:
Dec
Inc
Succ

Példa:
type
   Colors = (PIROS, KEK, ZOLD);       {ld. felsorolt típus}
 begin
   Writeln('Az 5-öt megelőző érték: ', Pred(5));
   Writeln('A 10-re következőérték: ', Succ(10));
   if Succ(PIROS) = KEK then
     Writeln('A Colors típusban a PIROS a KEK-et megelőző érték');
 end.

Random

Egy véletlenszámot állít elő.

Declarációja:
function Random[(Range: Word)]: <A paraméterrel azonos típus>;

Megjegyzés:
Ha Range hiányzik, akkor egy Real típusú 0<=X<1, egyébként egy Word típusú 0<=X<Range számot állít elő. Használat előtt célszerű a véletlenszám generátort a Randomize eljárással inicializálni.

Lásd még:
Randomize

Példa:
 uses Crt;
 begin
   Randomize;
   repeat
     { Véletlenszámokat ír ki}
     Writeln (Random(1000));
   until KeyPressed;
 end.

 Randomize

Inicializálja a beépített véletlenszám generátort.

Declarációja:
Procedure Randomize;

Lásd még:
Random

Példa:
 uses Crt;
 begin
   Randomize;
   repeat
     { Véletlenszámokat ír ki}
     Writeln (Random(1000));
   until KeyPressed;
 end.

Round

Egy valós értéket egésszé kerekít.

Declarációja:
function Round(X: Real): Longint;

Lásd még:
Int
Trunc

Példa:
begin
   Writeln(1.4, ' -ből  ', Round(1.4), ' lesz');
   Writeln(1.5, ' -ből  ', Round(1.5), ' lesz');
   Writeln(-1.4, ' -ből  ', Round(-1.4), ' lesz');
   Writeln(-1.5, ' -ből  ', Round(-1.5), ' lesz');
 end.

Sin

Visszatérési értéke az argumentum szinusza.

Declarációja:
function Sin(X: Real): Real;

Megjegyzés:
Az X szög radiánban értendő.

Lásd még:
ArcTan
Cos

Példa:
var
  R: Real;
begin
  R := Sin(Pi);
  Writeln ('Pi szinusza: ', R);
  Readln;
end.

Sqr

Visszatérési értéke, az argumentummal azonos típusú,  az argumentum négyzete.

Declarációja:
function Sqr(X): <A paraméterrel azonos típus>;

Lásd még:
Sqrt

Példa:
begin
   Writeln('5 négyzete: ', Sqr(5));
   Writeln('2 négyzetgyöke: ', Sqrt(2.0));
 end.

Sqrt

Visszatérési értéke az argumentum négyzetgyöke.

Declarációja:
function Sqrt(X: Real): Real;

Lásd még:
Sqr

Példa:
begin
   Writeln('5 négyzete: ', Sqr(5));
   Writeln('2 négyzetgyöke: ', Sqrt(2.0));
 end.

Str

Egy numerikus értéket karakterlánccá konvertál.

Declarációja:
Procedure Str(X [: Mezőszélesség [: Tizedesjegyek ]]; var S:string);

Megjegyzés:
Az X numerikus kifejezést egy olyan sztringgé konvertálja, amely a kifejezés kiírásakor megjelenne, és elhelyezi az S változóban.

Lásd még:
Val
Write

Példa:
uses graph;
var eredm: real;
      s:string;
begin
  ...
  ...
  Str(eredm:10:2, s);
  OutTextXY(10, 10, s);   {Grafikus módban csak sztringet irathatunk ki a képernyőre}
end.

Succ

A paraméterét követő értéket adja vissza.

Declarációja:
function Succ(X): <A paraméterrel azonos típus>;

Megjegyzés:
X egy sorszámozott típusú kifejezés.

Lásd még:
Dec
Inc
Pred

Példa:
type
   Colors = (PIROS, KEK, ZOLD);       {ld. felsorolt típus}
 begin
   Writeln('Az 5-öt megelőző érték: ', Pred(5));
   Writeln('A 10-re következőérték: ', Succ(10));
   if Succ(PIROS) = KEK then
     Writeln('A Colors típusban a PIROS a KEK-et megelőző érték');
 end.

Trunc

Egy valós értéket egésszé csonkít a törtrész levágásával.

Declarációja:
function Trunc(X: Real): Longint;

Lásd még:
Int
Round

Példa:
begin
   Writeln(1.4, ' -ből  ', Trunc(1.4), ' lesz');
   Writeln(1.5, ' -ből  ', Trunc(1.5), ' lesz');
   Writeln(-1.4, ' -ből  ', Trunc(-1.4), ' lesz');
   Writeln(-1.5, ' -ből  ', Trunc(-1.5), ' lesz');
 end.

 Val

Egy karakterláncot numerikus értéké konvertál.

Declarációja:
Procedure Val(S; var V; var Kod: Integer);
ahol:
S egy karakterlánc, amely egy előjeles számot alkot
V egy integer vagy egy real típusú változó
Kod egy integer változó.

Megjegyzés:
Az S karakterláncot V típusának megfelelően numerikussá konvertálja, és elhelyezi a V változóban. Ha sikerült az átalakítás, akkor a Kod értéke 0, egyébként az átalakítás során talált első hibás karakter pozíciója.

Lásd még:
Str

Példa:
var A, Kod: Integer;
begin
  Val('123?', A, Kod);
  if Kod = 0 then
    WriteLn(A)
  else
    WriteLn('Hiba a ', Kod,'. pozícióban)
end.