
CAPTULO 14   -   FUNES E PROCEDIMENTOS PARA MANIPULAO NUMRICA

ABS
 uma funo que retorna o valor absoluto de uma expresso numrica. Pode
ser utilizada na declarao de constantes, e na edio de "watches".
            ABS(<x>):Tipo;
O tipo de retorno  o mesmo do parmetro x

Exemplo:
PROGRAM ABS_TESTE;
VAR
    r:REAL;
    i:INTEGER;
BEGIN
    r:=ABS(-4.7);    {r=4.7}
    i:=ABS(-168);    {I=168}
    WRITELN(ABS(-.89);
END.

ARCTAN
Esta funo retorna o arco de tangente do argumento utilizado. O Turbo
Pascal no dispe de funo para tangente, porm podemos simul-la
utilizando seno/co-seno
            ARCTAN(<x>:REAL):REAL;

Exemplo:
PROGRAM teste_arqtan;

VAR
    result :real;

BEGIN
    result:=ARCTAN(PI);    {PI  uma funo predefinida do Turbo Pascal}
    WRITELN(O arco de tangente de PI   , result);
    WRITELN(O arco de tangente de 0.1  ,ARCTAN(0.1);
END.

COS
Esta funo nos retorna o valor do co-seno de um argumento passado como
parmetro. Sua sintaxe:
            COS(<r>:REAL):REAL;

Exemplo:
PROGRAM teste_cos;

VAR
    result : REAL;

BEGIN
    WRITELN(O coseno de PI  , COS(PI));
END.

DEC
 Este  um procedimento que permite-nos decrementar uma varivel numrica
inteira, em uma ou mais unidades. Se no for usado parmetro para decremento
este ser assumido 1. Sua sintaxe:
            DEC(VAR<x>[;n:LONGINT]);

Exemplo:
PROGRAM teste_dec;

VAR
    r: LONGINT;

BEGIN
    R:=5;
    DEC(r);
    WRITELN(O valor de "r" decrementado de 1, r:3);
    DEC(r,7);
    WRITELN(O valor de "r" decrementado de 7 ,r:3);
    READLN;
END.

    
EXP
Esta funo retorna o valor exponencial do argumento passado como parmetro.
Sua sintaxe:
            EXP(<r>:REAL):REAL;

Exemplo:
PROGRAM teste_exp;

BEGIN
    WRITELN(O valor exponencial "e"  , EXP(1.0));
END.

  A funo FRAC retorna a parte fracionria do argumento passado como par-
metro. No caso de um nmero negativo, a parte fracionria tambm ser ne-
gativa. Sua sintaxe: 
FRAC (<r>: REAL) : REAL;

Exemplo:

PROGRAM teste_frac;

BEGIN
  WRITELN (a parte fracionria de 12,8768 ,FRAC (12.8768));
  WRITELN (e a de -12,8768 , FRAC (-12.8768));
  END.

HI   funo que retorna a parte alta de uma constante numrica passada como
parmetro. Sua sintaxe

HI (<r>) : BYTE;
Exemplo:

PROGRAM teste_hi;


VAR
   w : WORD;
   i : INTEGER;
   b : BYTE;
   l : LONGINT;
BEGIN   
     w := $1234;
     i := -w;
     b := w;    
     l := w;
     WRITELN (as partes altas de "w , HI (w),  "i", HI (i), "b" , HI
(b), "l" , HI (l));
END.

  O valor $1234 est na base 16 exadecimal, equivalente ao valor decimal
4660 ou o binrio 0001001000110100, ou seja, 18e52. Para cada parte do nmero,
quando passamos o valor para a varivel "i" do tipo INTEGER, fizemos a nega-
o do nmero, ou seja, todas as posies ficaram invertidas, onde era 0 ficou
sendo 1 e vice-versa 237 e 203 para a parte alta e baixa respecitivamente.

INC   este  um procedimento que permite-nos incrementar uma varivel
numrica inteira, em uma ou mais unidades e se no for usado parmetro para
incremento, este ser assumido 1. Sua sintaxe:

INC (VAR <x> [; n: LONGINT]);
EXEMPLO:
PROGRAM teste_inc;
VAR
   r : LONGINT;
BEGIN   
     r := 5;
     INC (r);
     WRITELN (o valor de "r" incrementado de 1, r:3);
     INC (r,7);
     WRITELN (o valor de "r" incrementado de 7, r:3);
     READLN;
END.

INT   funo que nos retorna o valor inteiro de uma varivel do tipo real.
 importante notar que esta funo retorna o contedo inteiro, porm no 
formato real. Sua sintaxe:

INT (<x>: REAL) : REAL;
EXEMPLO:

PROGRAM teste_int;
VAR
   r : REAL;
BEGIN   
     r := 234.678;
     WRITELN (a parte inteira de "r", r:6:3,  , INT (r):6:3);
     WRITELN (a parte inteira de "-r" , -r:6:3,  , INT(-r):6:3);
     READLN;
END.

LN   esta funo nos retorna o logartmo passado como parmetro. Sua sintaxe:

LN (<r>: REAL) : REAL;
EXEMPLO:

PROGRAM teste_ln;

BEGIN
     WRITELN (o logartmo natural de "e"  , LN (EXP(1.0)):5:2);
END.  

LO   funo que retorna a parte baixa de uma constante numrica passada 
como parmetro. Sua sintaxe:

LO (<r>): BYTE;
EXEMPLO:

PROGRAM teste_lo;
VAR
   w : WORD;
   i : INTEGER;
   b : BYTE;
   l : LONGINT:
   

BEGIN
     w := $1234;
     i := -w;
     b := w;
     l := w;
     WRITELN (as partes altas de "w", LO (w), "i",
                  LO (i),"b",LO(b),"l", LO(l));
END.
 O valor $1234 est na base 16, exadecimal, equivale ao valor decimal 4660
ou o binrio 0001001000110100, ou seja, 18e52, para cada parte do nmero.
Quando passamos o valor para a varivel "i" do tipo INTEGER, fizemos a nega-
o do nmero, ou seja, todas as posies ficaram invertidas onde era 0 
ficou sendo 1 e vice_versa 237e203 para a parte alta e baixa respectivamente.

PI   Esta funo nos retorna o valor de PI, 3,1415926535897932385. Sua sintaxe:

PI : REAL;
EXEMPLO:

PROGRAM teste_pi;
BEGIN
     WRITELN (o valor de PI ->, PI);
END.

ODD   esta funo nos retorna um valor verdadeiro se o argumento passado
como parmetro for par, caso contrrio retorna falso. Sua sintaxe:
ODD (<n>: LONGINT) : BOOLEAN;
EXEMPLO:

PROGRAM teste_odd;
VAR
   n : WORD;
BEGIN   
     WRITELN (entre com um nmer);
     READLN (N);
     IF ODD (n)
       THEN
          WRITELN (o nmero ,n, impar);
END.

RANDOM   esta funo nos retorna um nmero aleatrio que pode variar de 0 a 1,
ou por um limite passado como parmetro. Sua sintaxe:

RANDOM [(<n>:WORD)]: (inteiro ou real);
EXEMPLO:

PROGRAM teste_random;
VAR
   n, i : BYTE;
BEGIN   
     FOR i := 1 TO 5 DO
       WRITELN (O ,i, o nmer, RANDOM (100));
END.

RANDOMIZE   esta funo permite-nos gerar uma nova semente para a gerao
do nmero randomico. Sua sintaxe:

RANDOMIZE;
  Se no exemplo anterior executarmos o programa mais de uma vez, notaremos
que os nmeros gerados so sempre os mesmos e se usarmos o procedimento 
RANDOMIZE no seu incio, conseguiremos eliminar este tipo de problema:
PROGRAM teste_randomize:

VAR
   n, i : BYTE;
BEGIN   
     RANDOMIZE;
     FOR i := 1 TO 5 DO
          WRITELN (o ,i, o nmero ,RANDOM(100));
END.

ROUND   esta funo nos retorna um nmero real convertido em inteiro e arre-
dondado, seu valor decimal estiver abaixo de 5, o nmero  arredondado para
baixo, caso contrrio ser arredondado para cima. Sua sintaxe:
ROUND (<r>: REAL): LONGINT;
EXEMPLO:
PROGRAM teste_round;
BEGIN
     WRITELN (1.4, arredondad, ROUND(1.4));
     WRITELN (1.5, arredondad, ROUND(1.5));
     WRITELN (-1.4, arredondad, ROUND(-1.4));
     WRITELN (-1.5, arredondad, ROUND(-1.5));
END.

SIN   esta funo nos retorna o seno de um argumento passado como parmetro.
Sua sintaxe:
SIN (<r>): REAL): REAL;
EXEMPLO:
PROGRAMteste_sin:
VAR
   result : REAL;
BEGIN
     WRITELN (o seno de PI e  , SIN (PI));
END.

SQR   esta funo nos retorna o parmetro elevado ao quadrado. Sua sintaxe:

SQR (<r> : (numrico)) : numrico;
  Como parmetro, so vlidos quaisquer tipos numricos e o retorno desta
funo ter o mesmo tipo que o parmetro passado como argumento. Veja um 
exemplo:
PROGRAM teste_sqr;
BEGIN
  WRITELN (5 ao quadrado  , SQR (5));
  WRITELN (2,5 ao quadrado  , SQR (2,5));
END.

SQRT   esta funo retorna a raiz quadrada do valor do argumento usado como
parmetro. Sua sintaxe:
SQRT (<r> : REAL) : REAL;
PROGRAM teste_sqrt;
BEGIN
  WRITELN (a raiz quadrada de 5  , SQRT (5));
  WRITELN (a raiz quadrada de 2,5  , SQRT(2.5));
END.

SWAP   esta funo nos retorna o valor passado como argumento no parmetro
invertido em sua ordem ou seja, a parte baixa do valor passa ser a alta e
a parte alta passa a ser a baixa. Sua sintaxe:
SWAP (<i> : qualquer_inteiro) : (o mesmo tipo do parmetro);
EXEMPLO:
PROGRAM teste_swap;
VAR
  w : WORD;
BEGIN  
  W := SWAP($1234);
END.
  Aps a execuo deste programa, a varivel "w" ter como contedo $3412.

TRUNC   esta funo retorna um valor inteiro truncado nas casas decimais.
Sua sintaxe:
TRUNC (<r> : REAL) : LONGINT;
PROGRAM teste_trunc;
BEGIN
  WRITELN (1.4,  truncado , TRUNC (1.4));
  WRITELN (1.5,  truncad, TRUNC (1.5));
  WRITELN (-1.4,  truncado , TRUNC (-1.4));
  WRITELN (-1.5,  truncado , TRUNC (-1.5));
END.
