DUzun's Web
Programare, proiecte personale, divertisment

Unit p129_19; { Probl 19, Parag 11, Pag 129 }

{--------------------------------------------------------------

    Sa se defineasca un subprogram care va:

    a) aduna masurile a 2 unghiuri (exprimate in grade, minute si secunde);

    b) scadea masurile a 2 unghiuri;

    c) inmulti masura unui unghi cu un nr natural;

    d) imparti cu rest masurile a doua unghiuri;

    c) compara masurile a 2 unghiuri

 --------------------------------------------------------------}

interface

​

uses

   CRT;

{--------------------------------------------------------------}

const

   maxSecunde = 360*60*60; { O rotatie completa. }

{--------------------------------------------------------------}

type

   TGrade = longint;

{--------------------------------------------------------------}

var

   G1, G2, G3: TGrade;

   c: word;

{--------------------------------------------------------------}

function grad2real(g: TGrade): real;

function grad2int(g: TGrade;var m,s: integer): integer;

function grad2str(gr: TGrade): string;

function int2grad(g,m,s: integer): TGrade;

function real2grad(r: real): TGrade;

{a}function addGrad(g1,g2: TGrade): TGrade;                {+}

{b}function subGrad(g1,g2: TGrade): TGrade;                {-}

{c}function mulGrad(g: TGrade; n: word): TGrade;           {*}

{d}function divGrad(g1,g2: TGrade;var rest: TGrade): word; {/} 

   function modGrad(g1,g2: TGrade;var cat: word): TGrade;  {%}

{e}function cmpGrad(g1,g2: TGrade): shortint;

procedure writeGrad(g: TGrade);

function  readGrad(b: byte): TGrade;{b: 0, 1-grad, 2-min, 3-sec}

function  randGrad(g: TGrade): TGrade;{Genereaza o val TGrade}

{--------------------------------------------------------------}

​

implementation

{--------------------------------------------------------------}

function grad2real(g: TGrade): real;

begin grad2real := (g mod maxSecunde) / 3600; end;

{--------------------------------------------------------------}

function grad2int(g: TGrade;var m,s: integer): integer;

begin

    s := g mod 60;

    g := g div 60; 

    m := g mod 60;

    grad2int := (g div 60);

end;

{--------------------------------------------------------------}

function grad2str(gr: TGrade): string;

var g, m, s: integer;

    st, rez: string;

begin

   g := grad2int(gr, m,s);

   str(g,st);      rez := st+'`';

   str(abs(m),st); rez := rez+st+'''';

   str(abs(s),st); rez := rez+st+'"';

   grad2str := rez;  {g`m's"}

end;

{--------------------------------------------------------------}

function int2grad(g,m,s: integer): TGrade;

begin int2grad := (g*3600 + m*60 + s) mod maxSecunde; end;

{--------------------------------------------------------------}

function real2grad(r: real): TGrade;

begin real2grad := trunc(r * 3600) mod maxSecunde; end;

{--------------------------------------------------------------}

{a}function addGrad(g1,g2: TGrade): TGrade;

 begin addGrad := (g1 + g2) mod maxSecunde; end;

{--------------------------------------------------------------}

{b}function subGrad(g1,g2: TGrade): TGrade;

 begin subGrad := (g1 - g2) mod maxSecunde; end;

{--------------------------------------------------------------}

{c}function mulGrad(g: TGrade; n: word): TGrade;

 begin mulGrad := (g*n) mod maxSecunde; end;

{--------------------------------------------------------------}

{d}function divGrad(g1,g2: TGrade;var rest: TGrade): word; 

begin 

  g1 := g1 mod maxSecunde; 

  g2 := g2 mod maxSecunde;

  rest := g1 mod g2; 

  divGrad := (g1 div g2); 

end;

{--------------------------------------------------------------}

function modGrad(g1,g2: TGrade;var cat: word): TGrade; 

var m: TGrade;

begin cat := divGrad(g1,g2, m); modGrad := m; end;

{--------------------------------------------------------------}

{e}function cmpGrad(g1,g2: TGrade): shortint;

begin

   g1 := subGrad(g1,g2);

   if g1 > 0 then cmpGrad :=  1 else {>}

   if g1 < 0 then cmpGrad := -1 else {<}

                  cmpGrad :=  0;     {=}

end;

{--------------------------------------------------------------}

function readGrad(b: byte): TGrade;

var g,m,s: integer;

begin

  if b > 0 then begin write('Grade:   '); readln(g); end else g := 0;

  if b > 1 then begin write('Minute:  '); readln(m); end else m := 0;

  if b > 2 then begin write('Secunde: '); readln(s); end else s := 0;

  readGrad := int2grad(g,m,s);

end;

{--------------------------------------------------------------}

procedure writeGrad(g: TGrade);

begin write(grad2str(g)); end;

{--------------------------------------------------------------}

function randGrad(g: TGrade): TGrade;

begin

   g := Random( ((g-1) mod maxSecunde + 1) shr 16 );

   randGrad := (g shl 16) or Random(g and (1 shl 16 - 1));

end;

{--------------------------------------------------------------}

​

BEGIN

{ Codul de mai jos este pentru a exemplifica utilizarea functiilor }

{ El poate fi inlaturat, fara a afecta functionarea modulului!     }

  clrscr;

  randomize;

  G1 := randGrad(maxSecunde);

  G2 := randGrad(maxSecunde);

{  G1 := readGrad(2);

  G2 := readGrad(3); }  

  c  := Random(MaxInt); 

  writeln;

  writeln(grad2str(G1),' + ', grad2str(G2),' = ',grad2str(addGrad(G1,G2)));

  writeln;

  writeln(grad2str(G1),' - ', grad2str(G2),' = ',grad2str(subGrad(G1,G2)));

  writeln;

  writeGrad(G1);   write(' * ', c, ' = ');   writeGrad(mulGrad(G1,c)); Writeln;

  { Numarul mai mic se ia ca impartitor }

  if cmpGrad(abs(G1),abs(G2)) < 0 then begin {G1 < G2}

     G3 := G2;

     G2 := G1;

     G1 := G3;

  end;

  { Asigura ca G2 sa nu fie nul }

  while cmpGrad(G2,0) = 0 do G2 := randGrad(maxSecunde);  

  G3 := modGrad(G1,G2, c);

  writeln;

  writeln(grad2str(G1),' / ', grad2str(G2),' = ',c,', rest = ',grad2str(G3));

  writeln;

END.

{--------------------------------------------------------------}

​

​