(*Bazele Matematici in calculatoare*)

(*Aplicatia electronica in pascal *)

(*Boca Adrian Marius 211*)
program BMC_BOCA;

uses crt;

type numar = record

vectcif:array[0..99] of byte; (* vector de numere
*)
bza,npoz:byte; (* bza=baza,
npoz=pozitia numarului *)
sfarsit;
sirnumr = array[0..99] of longint;

var a,b,c,nria,nrja,nrib,nrjb,nric,nrjc:numar;
nrbaza:2..50;
z:word;
ter,nmar:byte;
uk,uk1,uk2,cifnr:char;

subalgoritmul adunare (a,b:numar; var c:numar); (*adunarea numerelor*)

var t,i:word;
a1,b1:numar;
inceput
a1 <- a;
b1 <- b;
daca a1.npoz>b1.npoz atunci inceput
pentru i <- b1.npoz+1 pana la a1.npoz executa
b1.vectcif[i] <- 0;
b1.npoz <- a1.npoz;
sfarsit altfel daca a1.npoz<b1.npoz atunci inceput
pentru i <- a1.npoz+1 pana la b1.npoz
executa a1.vectcif[i] <- 0;
a1.npoz <- b1.npoz;
sfarsit;
t <- 0;
pentru i <- 0 pana la a1.npoz executa inceput
daca a1.vectcif[i]+b1.vectcif[i]+t<a1.bza atunci
inceput
c.vectcif[i] <- a1.vectcif[i]+b1.vectcif[i]+t;
t <- 0;
sfarsit
altfel
inceput
c.vectcif[i] <- (a1.vectcif[i]+b1.vectcif[i]+t)mod a1.bza;
t <- (a1.vectcif[i]+b1.vectcif[i]+t)div a1.bza;
sfarsit;
sfarsit;
daca t>0 atunci
inceput
inc(i);
c.vectcif[i] <- t;
sfarsit;
c.npoz <- i;
c.bza <- a1.bza;
sfarsit;
subalgoritmul inmultire (a:numar; cifra:byte; var c:numar); (*inmultirea
numerelor*)
var t,i:word;
a1:numar;
inceput
daca cifra=0 atunci
inceput
c.npoz <- 0;
c.bza <- a.bza;
c.vectcif[0] <- 0;
sfarsit
altfel
inceput
a1 <- a;
t <- 0;
pentru i <- 0 pana la a1.npoz executa
inceput
daca a1.vectcif[i]*cifra+t<a1.bza atunci
inceput
c.vectcif[i] <- a1.vectcif[i]*cifra+t;
t <- 0;
sfarsit
altfel
inceput
c.vectcif[i] <- (a1.vectcif[i] * cifra + t)
mod a1.bza;
t <- (a1.vectcif[i] * cifra + t ) div a1.bza;
sfarsit;
sfarsit;
daca t>0 atunci
inceput
inc(i);
c.vectcif[i] <- t;
sfarsit;
c.npoz <- i;
c.bza <- a1.bza;
sfarsit;
sfarsit;

subalgoritmul scadere (a,b:numar; var c:numar); (*diferenta numerelor*)

var t,i:word;
a1,b1:numar;

inceput
a1 <- a;
b1 <- b;
daca a1.npoz>b1.npoz atunci
inceput
pentru i <- b1.npoz + 1 pana la a1.npoz executa
b1.vectcif[i] <- 0;
b1.npoz <- a1.npoz;
sfarsit;
t <- 0;
pentru i <- 0 pana la a1.npoz executa
daca a1.vectcif[i] >= b1.vectcif[i]+t atunci
inceput
c.vectcif[i] <- a1.vectcif[i] - b1.vectcif[i] - t;
t <- 0;
 sfarsit
altfel
inceput
c.vectcif[i] <- a1.bza + a1.vectcif[i] - b1.vectcif[i]
- t;
t <- 1;
sfarsit;
c.npoz <- a1.npoz;
c.bza <- a1.bza;
daca c.npoz <> 0 atunci
cat timp (c.vectcif[c.npoz]=0) si (c.npoz<>0) executa
dec(c.npoz);
sfarsit;

subalgoritmul inversa (var a:numar); (*ordinea inversa a cifrelor

numarului*)
var b:numar;
i:integer;
inceput
b.bza <- a.bza;
b.npoz <- a.npoz;
pentru i <- b.npoz downto 0 executa
b.vectcif[b.npoz-i] <- a.vectcif[i];
a <- b;
sfarsit;

subalgoritmul impartire (a:numar; cifra:byte; var c:numar; var t:byte);

(*impartirea numarului*)
var a1:numar;
i:byte;
inceput
a1 <- a;
c.bza <- a1.bza;
c.npoz <- a1.npoz;
inversa(a1);
t <- 0;
pentru i <- 0 pana la a1.npoz executa
inceput
c.vectcif[i] <- (a1.vectcif[i]+t*a1.bza)div cifra;
t <- (a1.vectcif[i] + t * a1.bza) mod cifra;
sfarsit;
inversa(c);
daca c.npoz <> 0 atunci
cat timp (c.vectcif[c.npoz] = 0) si (c.npoz <> 0) executa
dec(c.npoz);
sfarsit;

subalgoritmul re_nat (nri,nrj:numar; var c:numar); (*transforma din real

in natural numarul*)
var i:byte;
d:numar;
inceput
c <- nri;
pentru i <- c.npoz + 1 pana la c.npoz + 10 executa
c.vectcif[i] <- 0;
c.npoz <- c.npoz + 10;
pentru i <- c.npoz downto 10 executa
c.vectcif[i] <- c.vectcif[i - 10];
 pentru i <- 0 pana la 9 executa
c.vectcif[i] <- 0;
daca nrj.npoz=9 atunci
d <- nrj
altfel
inceput
d <- nrj;
pentru i <- d.npoz + 1 pana la 9 executa
d.vectcif[i] <- 0;
pentru i <- 9 downto 9 - d.npoz executa
d.vectcif[i] <- d.vectcif[i-9 + d.npoz];
pentru i <- 0 pana la 8 - d.npoz executa
d.vectcif[i] <- 0;
d.npoz <- 9;
sfarsit;
adunare(c,d,c);
sfarsit;

subalgoritmul nat_re (var nri,nrj:numar; c:numar); (*transforima din

natural in real numarul*)
var i:byte;
inceput
pentru i <- 0 pana la 9 executa
nrj.vectcif[i] <- c.vectcif[i];
nrj.npoz <- 9;
nrj.bza <- c.bza;
pentru i <- 10 pana la c.npoz executa
nri.vectcif[i - 10] <- c.vectcif[i];
nri.npoz <- c.npoz - 10;
nri.bza <- c.bza;
sfarsit;

subalgoritmul baza10_baza (var a:numar; b:byte); (*transforma numarul din

nrbaza 10 in nrbaza b*)
var c,rez:numar;
i:integer;
t:byte;
inceput
i <- -1;
repeat
impartire (a,b,c,t);
a <- c;
inc(i);
rez.vectcif[i] <- t;
until ((a.npoz = 0) si (a.vectcif[a.npoz] = 0));
rez.npoz <- i;
rez.bza <- b;
a <- rez;
sfarsit;

subalgoritmul Val_To_Nr(val:longint; var a:numar);(*numar longint va fi

transformat in numar*)
var i:integer;
inceput
daca val = 0 atunci
inceput
a.bza <- 10;
i <- 0;
 a.vectcif[0] <- 0;
sfarsit
altfel
inceput
a.bza <- 10;
i <- -1;
cat timp val>0 executa
inceput
inc(i);
a.vectcif[i] <- val mod 10;
val <- val div 10;
sfarsit;
sfarsit;
a.npoz <- i;
sfarsit;

function corectnr(a:numar):boolean; (*verifica daca numarul e corect in

nrbaza*)
var b:boolean;
i:word;
inceput
b <- true;
pentru i <- 0 pana la a.npoz executa
daca a.vectcif[i] >= a.bza atunci
b <- false;
corectnr <- b;
sfarsit;

subalgoritmul crearenr (var a:numar; b:byte); (*crearea unui numar intr-o

nrbaza*)
var s:string;
i:integer;
cor:boolean;
inceput
cor <- false;
cat timp not cor executa
inceput
a.bza <- b;
readln(s);
a.npoz <- length(s)-1;
pentru i <- a.npoz downto 0 executa
daca s[i+1]<='9' atunci
a.vectcif[a.npoz-i] <- ord(s[i+1])-48
altfel
a.vectcif[a.npoz-i] <- ord(UPCASE(s[i+1]))-55;
cor <- corectnr(a);
daca not cor atunci
write('Numar Incorect. Incercati din nou ');
sfarsit;
sfarsit;

function putere (x,n:longint):longint;(*x se ridica la puterea n*)

var i,nr:longint;
inceput
daca n = 0 atunci nr <- 1 altfel
inceput
nr <- 1;
pentru i <- 1 pana la n executa nr <- nr * x;
 sfarsit;
putere <- nr;
sfarsit;

subalgoritmul sircif(var vectcif:sirnumr; var n:byte; a:numar); (*se

creeaza sirul de cifre inmultite cu
nrbaza la puterea pozitiei cifrelor*)
var i:integer;
inceput
n <- a.npoz;
pentru i <- 0 pana la a.npoz executa
vectcif[i] <- a.vectcif[i] * putere (a.bza,i);
sfarsit;

subalgoritmul Convert_Fract (var a:numar; b:byte); (*convertirea partii

fractionare*)
var a1,c:numar;
i,n:byte;
inceput
n <- 9;
c.npoz <- 0;
pentru i <- 0 pana la n executa
inceput
inmultire(a,b,a1);
daca a1.npoz>a.npoz atunci
c.vectcif[c.npoz] <- a1.vectcif[a1.npoz]
altfel
c.vectcif[c.npoz] <- 0;
inc(c.npoz);
daca a1.npoz>a.npoz atunci
dec(a1.npoz);
a <- a1;
sfarsit;
dec(c.npoz);
cat timp (c.vectcif[c.npoz]=0)si(c.npoz<>0) executa
dec(c.npoz);
inversa(c);
a <- c;
a.bza <- b;
sfarsit;

function zero (a:numar):boolean;(*verifica daca un numar este zero sau

nu*)
var b:boolean;
inceput
daca (a.npoz=0) si (a.vectcif[0] = 0) atunci b <- true
altfel
b <- false;
zero <- b;
sfarsit;

subalgoritmul convbaza_inmult (var a:numar; q:byte); (*converteste un

numar prin inmultiri succesive*)
var c,rezultat:numar;
vectcif:sirnumr;
n,i:byte;
inceput
sircif (vectcif,n,a);
 rezultat.bza <- q;
rezultat.npoz <- 0;
rezultat.vectcif[0] <- 0;
pentru i <- n downto 0 executa
inceput
val_pana la_nr(vectcif[i],c);
baza10_baza(c,q);
adunare(rezultat,c,a);
rezultat <- a;
sfarsit;
sfarsit;

subalgoritmul convbaza_impar (var a:numar; q:byte);(*converteste un numar

prin impartiri succesive*)
var c,cat:numar;
rest:byte;
i:integer;
inceput
c.bza <- q;
i <- 0;
cat timp zero (a) = false executa
inceput
impartire (a,q,cat,rest);
c.vectcif[i] <- rest;
inc(i);
a <- cat;
sfarsit;
c.npoz <- i-1;
a <- c;
sfarsit;

subalgoritmul afisare(a:numar); (*afisarea unui numar in ordinea

adecvata*)
var i:byte;
inceput
pentru i <- a.npoz downto 0 executa
daca a.vectcif[i] <= 9 atunci write (a.vectcif[i])
altfel write (chr (ord (a.vectcif[i]) + 55));
sfarsit;

function comparare (a,b:numar):shortint;(*compara numerele*)

var a1,b1:numar;
k:byte;
m:shortint;
inceput
a1 <- a;
b1 <- b;
daca a.bza <> b.bza atunci
inceput
daca a.bza > b.bza atunci
convbaza_impar (a1,b1.bza)
altfel
convbaza_inmult (a1,b1.bza);
sfarsit;
daca b1.npoz < a1.npoz atunci
m <- 1;
daca b1.npoz > a1.npoz atunci
m <- -1;
 daca b1.bza = a1.bza atunci
inceput
k <- a1.npoz;
cat timp (a1.vectcif[k] = b1.vectcif[k]) si (k>0) executa
dec(k);
daca a1.vectcif[k] > b1.vectcif[k] atunci
m <- 1
altfel
daca a1.vectcif[k] < b1.vectcif[k] atunci
m <- -1
altfel
m <- 0;
sfarsit;
comparare <- m;
sfarsit;

subalgoritmul nradunare;
inceput
clrscr;
writeln ('* * Adunarea * *');
writeln;
write ('*-> Baza pentru A este : ');
readln (nrbaza);
writeln;
write ('*-> Numarul A este : ');
crearenr (a,nrbaza);
writeln;
write ('*-> Baza pentru B este : ');
readln (nrbaza);
writeln;
write ('*-> Numarul B este : ');
crearenr (b,nrbaza);
writeln;
write ('*-> Baza rezultatului este : ');
readln (nrbaza);
daca a.bza > nrbaza atunci
convbaza_impar (a,nrbaza)
altfel
daca a.bza < nrbaza atunci
convbaza_inmult (a,nrbaza);
daca b.bza > nrbaza atunci
convbaza_impar (b,nrbaza)
altfel
daca b.bza < nrbaza atunci
convbaza_inmult (b,nrbaza);
writeln;
write ('Rezultat : ');
adunare (a,b,c);
afisare (c);
readkey;
sfarsit;

subalgoritmul nrscadere;
inceput
clrscr;
writeln ('* * Scadere * *');
writeln;
write ('*-> Baza pentru A este : ');
 readln (nrbaza);
write ('*-> Numarul A este : ');
crearenr (a,nrbaza);
write ('*-> Baza pentru B este : ');
readln (nrbaza);
write ('*-> Numarul B este : ');
crearenr (b,nrbaza);
write ('*-> Baza rezultat este : ');
readln (nrbaza);
daca a.bza > nrbaza atunci
convbaza_impar (a,nrbaza)
altfel
daca a.bza < nrbaza atunci
convbaza_inmult (a,nrbaza);
daca b.bza > nrbaza atunci
convbaza_impar (b,nrbaza)
altfel
daca b.bza < nrbaza atunci
convbaza_inmult (b,nrbaza);
writeln;
write ('Rezultat : ');
scadere (a,b,c);
afisare (c);
readkey;
sfarsit;

subalgoritmul nrinmultire;
inceput
clrscr;
writeln ('* * Inmultire * *');
writeln;
write ('*-> Baza este : ');
readln (nrbaza);
write ('*-> Numarul A este : ');
crearenr (a,nrbaza);
nmar <- nrbaza;
cat timp nmar >= nrbaza executa
inceput
write ('*-> Numarul B este : ');
readln (cifnr);
daca ord(cifnr)<=ord('9') atunci
nmar <- ord(cifnr)-48
altfel
nmar <- ord(UPCASE(cifnr))-55;
sfarsit;
inmultire (a,nmar,c);
writeln;
write ('Rezultat : ');
afisare (c);
readkey;
sfarsit;

subalgoritmul nrimpartire;
inceput
clrscr;
writeln ('* * Impartire * *');
writeln;
write ('*-> Baza este : ');
 readln (nrbaza);
write ('*-> Numarul A este : ');
crearenr (a,nrbaza);
nmar <- nrbaza;
cat timp (nmar >= nrbaza) or (nmar = 0) executa
inceput
write('*-> Numarul B este : ');
readln(cifnr);
daca ord(cifnr)<=ord('9') atunci
nmar <- ord(cifnr)-48
altfel
nmar <- ord(UPCASE(cifnr))-55;
sfarsit;
impartire (a,nmar,c,ter);
writeln;
write (' Rezultat : ');
afisare (c);
write (' rest ');
daca ter <= 9 atunci
write(ter)
altfel
write (chr (ord (ter) + 55));
readkey;
sfarsit;

subalgoritmul nrcomparare;
inceput
clrscr;
writeln ('* * Comparare * *');
writeln;
write ('*-> Baza numarului A este : ');
readln (nrbaza);
write ('*-> Numarul A este : ');
crearenr (a,nrbaza);
write ('*-> Baza numarului B este : ');
readln (nrbaza);
write ('*-> Numarul B este : ');
crearenr (b,nrbaza);
z <- comparare (a,b);
writeln;
write ('Rezultat : ');
daca z = 0 atunci
writeln (' * A = B * ')
altfel
daca z=1 atunci
writeln (' * A > B * ')
altfel
writeln (' * A < B * ');
writeln;
readkey;
sfarsit;

subalgoritmul nrconversii;
inceput
repeat
clrscr;
writeln ('* * Conversii * *');
writeln;
 writeln ('*-> 1. - Calcul in baza data - ');
writeln ('*-> 2. - Calcul in baza rezultat - ');
writeln ('*-> 3. - Folosirea unei baze auxiliare - ');
writeln;
writeln ('*Esc* Inapoi');
uk2 <- readkey;
case ord (uk2) of
49: inceput
clrscr;
writeln ('* *1. - Calcul in baza data - ');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Dati numarul : ');
crearenr (a,nrbaza);
write ('*-> Dati baza rezultat : ');
readln (nrbaza);
convbaza_impar (a,nrbaza);
writeln;
writeln;
write('Rezultat : ');
afisare (a);
readkey;
sfarsit;
50: inceput
clrscr;
writeln ('* *2. - Calcul in baza rezultat - ');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Dati numarul : ');
crearenr (a,nrbaza);
write ('*-> Dati baza rezultat : ');
readln (nrbaza);
convbaza_inmult (a,nrbaza);
writeln;
writeln;
write('Rezultat : ');
afisare (a);
readkey;
sfarsit;
51: inceput
clrscr;
writeln ('* *3. - Folosirea unei baze auxiliare -
');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Dati numarul : ');
crearenr (a,nrbaza);
write ('*-> Dati baza rezultat : ');
readln (nrbaza);
daca a.bza > 10 atunci
convbaza_impar (a,10)
altfel
daca a.bza<10 atunci
convbaza_inmult (a,10);
daca nrbaza > 10 atunci
 convbaza_impar (a,nrbaza)
altfel
daca nrbaza < 10 atunci
convbaza_inmult (a,nrbaza);
writeln;
writeln;
write('Rezultat : ');
afisare (a);
readkey;
sfarsit;
sfarsit;
until (ord (uk2) = 27);
sfarsit;

subalgoritmul rradunar;
inceput
clrscr;
writeln ('* * Adunare * *');
writeln;
writeln;
writeln;
write ('*-> Baza numarului A este : ');
readln (nrbaza);
write ('*-> Parte intreaga a lui A este : ');
crearenr (nria,nrbaza);
write ('*-> Parte fractionara a lui A este : ');
crearenr (nrja,nrbaza);
write ('*-> Baza numarului B este : ');
readln (nrbaza);
write ('*-> Parte intreaga a lui B este : ');
crearenr (nrib,nrbaza);
write ('*-> Parte fractionara a lui B este : ');
crearenr (nrjb,nrbaza);
write ('*-> Baza rezultat este : ');
readln (nrbaza);
convbaza_impar (nria,nrbaza);
Convert_Fract (nrja,nrbaza);
convbaza_impar (nrib,nrbaza);
Convert_Fract (nrjb,nrbaza);
re_nat (nria,nrja,a);
re_nat (nrib,nrjb,b);
adunare (a,b,c);
writeln;
writeln;
write('Rezultat : ');
nat_re (nric,nrjc,c);
afisare (nric);
write (',');
afisare (nrjc);
readkey;
sfarsit;
subalgoritmul rrscader;
inceput
clrscr;
writeln ('* * Scadere * *');
writeln;
writeln;
writeln;
 write ('*-> Baza numarului A este : ');
readln (nrbaza);
write ('*-> Parte intreaga a lui A este : ');
crearenr (nria,nrbaza);
write ('*-> Parte fractionara a lui A este : ');
crearenr (nrja,nrbaza);
write ('*-> Baza numarului B este : ');
readln (nrbaza);
write ('*-> Parte intreaga a lui B este : ');
crearenr (nrib,nrbaza);
write ('*-> Parte fractionara a lui B este : ');
crearenr (nrjb,nrbaza);
write ('*-> Baza rezultat este : ');
readln (nrbaza);
convbaza_impar (nria,nrbaza);
Convert_Fract (nrja,nrbaza);
convbaza_impar (nrib,nrbaza);
Convert_Fract (nrjb,nrbaza);
re_nat (nria,nrja,a);
re_nat (nrib,nrjb,b);
writeln;
writeln;
scadere (a,b,c);
nat_re (nric,nrjc,c);
write ('Rezultat : ');
afisare (nric);
write (',');
afisare (nrjc);
readkey;
sfarsit;

subalgoritmul rrmultir;
inceput
clrscr;
writeln ('* * Inmultire * *');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Partea intreaga a lui A este : ');
crearenr (nria,nrbaza);
write ('*-> Partea fractionara a lui A este : ');
crearenr (nrja,nrbaza);
re_nat (nria,nrja,a);
nmar <- nrbaza;
cat timp nmar >= nrbaza executa
inceput
write ('*-> Numarul B este : ');
readln (cifnr);
daca ord (cifnr) <= ord ('9') atunci
nmar <- ord (cifnr) - 48
altfel
nmar <- ord (UPCASE (cifnr)) - 55;
sfarsit;
inmultire (a,nmar,c);
nat_re (nric,nrjc,c);
writeln;
write ('Rezultat : ');
afisare (nric);
 write (',');
afisare (nrjc);
readkey;
sfarsit;

subalgoritmul rrimpartir;
inceput
clrscr;
writeln ('* * Impartire * *');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Partea intreaga a lui A este : ');
crearenr (nria,nrbaza);
write ('*-> Partea fractionara a lui A este : ');
crearenr (nrja,nrbaza);
re_nat (nria,nrja,a);
nmar <- nrbaza;
cat timp (nmar >= nrbaza) or (nmar = 0) executa
inceput
write ('*-> Numarul B este : ');
readln(cifnr);
daca ord (cifnr) <= ord ('9') atunci
nmar <- ord (cifnr) - 48
altfel
nmar <- ord (UPCASE (cifnr)) - 55;
sfarsit;
impartire (a,nmar,c,ter);
nat_re (nric,nrjc,c);
writeln;
write ('Rezultat : ');
afisare (nric);
write (',');
afisare (nrjc);
readkey;
sfarsit;

subalgoritmul rrcomparar;
inceput
clrscr;
writeln ('* * Comparare * *');
writeln;
write ('*-> Baza numarului A este : ');
readln (nrbaza);
write ('*-> Parte intreaga a lui A este : ');
crearenr (nria,nrbaza);
write ('*-> Parte fractionara a lui A este :');
crearenr (nrja,nrbaza);
write ('*-> Baza numarului B este : ');
readln (nrbaza);
write ('*-> Parte intreaga a lui B este : ');
crearenr (nrib,nrbaza);
write ('*-> Parte fractionara a lui B este : ');
crearenr (nrjb,nrbaza);
re_nat (nria,nrja,a);
re_nat (nrib,nrjb,b);
z <- comparare (a,b);
writeln;
 writeln;
write('Rezultat : ');
daca z = 0 atunci
writeln (' * A = B * ')
altfel
daca z = 1 atunci
writeln(' * A > B * ')
altfel
writeln (' * A < B * ');
readkey;
sfarsit;

subalgoritmul rrconvers;
inceput
repeat
clrscr;
writeln ('* * Conversii * *');
writeln;
writeln ('*-> 1. - Inmultiri si impartiri succesive - ');
writeln ('*-> 2. - Substitutie - ');
writeln;
writeln ('*Esc* Inapoi');
uk2 <- readkey;
case ord (uk2) of
49: inceput
clrscr;
writeln ('* *1. - Inmultiri si impartiri succesive
- ');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Partea intreaga a lui A este :');
crearenr (nria,nrbaza);
write ('*-> Partea fractionara a lui A este : ');
crearenr (nrja,nrbaza);
write ('*-> Dati baza rezultat : ');
readln (nrbaza);
convbaza_impar (nria,nrbaza);
Convert_Fract (nrja,nrbaza);
writeln;
writeln;
write ('Rezultat : ');
afisare (nria);
write (',');
afisare (nrja);
readkey;
sfarsit;
50: inceput
clrscr;
writeln ('* *2. - Substitutie - ');
writeln;
write ('*-> Dati baza : ');
readln (nrbaza);
write ('*-> Partea intreaga a lui A este : ');
crearenr (nria,nrbaza);
write ('*-> Partea fractionara a lui B este : ');
crearenr (nrja,nrbaza);
write ('*-> Dati baza rezultat : ');
 readln (nrbaza);
convbaza_inmult (nria,nrbaza);
Convert_Fract (nrja,nrbaza);
writeln;
writeln;
write ('Rezultat : ');
afisare (nria);
write (',');
afisare (nrja);
readkey;
sfarsit;
sfarsit;
until (ord (uk2) = 27);
sfarsit;

(*program principal*)
inceput
clrscr;
repeat
clrscr;
writeln;
writeln ('* * Program Principal * *');
writeln;
writeln;
writeln ('*-> 1. Numere Naturale - ');
writeln;
writeln;
writeln ('*-> 2. Numere Reale Pozitive - ');
writeln;
writeln;
writeln;
writeln;
writeln;
writeln;
writeln;
writeln;
writeln ('*Esc* Iesire');
uk <- readkey;
case ord (uk) of
49: inceput
repeat
clrscr;
writeln ('* * Numere Naturale *
*');
writeln;
writeln ('*-> 1. Adunare * ');
writeln;
writeln ('*-> 2. Scadere * ');
writeln;
writeln ('*-> 3. Inmultire * ');
writeln;
writeln ('*-> 4. Impartire * ');
writeln;
writeln ('*-> 5. Comparare * ');
writeln;
writeln ('*-> 6. Conversii * ');
writeln;
writeln;
 writeln ('*Esc* Inapoi');
uk1 <- readkey;
case ord (uk1) of
49:nradunare;
50:nrscadere;
51:nrinmultire;
52:nrimpartire;
53:nrcomparare;
54:nrconversii;
sfarsit;
until (ord (uk1) = 27);
sfarsit;
50: inceput
repeat
clrscr;
writeln ('* * Numere Reale * *');
writeln;
writeln ('*-> 1. Adunare * ');
writeln;
writeln ('*-> 2. Scadere * ');
writeln;
writeln ('*-> 3. Inmultire * ');
writeln;
writeln ('*-> 4. Impartire * ');
writeln;
writeln ('*-> 5. Comparare * ');
writeln;
writeln ('*-> 6. Conversii * ');
writeln;
writeln;
writeln ('*Esc* Inapoi');
uk1 <- readkey;
case ord (uk1) of
49:rradunar;
50:rrscader;
51:rrmultir;
52:rrimpartir;
53:rrcomparar;
54:rrconvers;
sfarsit;
until (ord(uk1)=27);
sfarsit;
sfarsit;
until ord(uk)=27;
sfarsit.