UNITATEA DE NVARE NR. 1 LIMBAJUL DE PROGRAMARE S. NOIUNEA DE FUNCIE CALCULABIL.

MACROINSTRUCIUNI N LIMBAJUL S
Cuprins
1.1. 1.2. 1.3. 1.4. 1.5. 1.6. 1.7. 1.8. 1.9. 1.10. Obiectivele unitii de nvare nr. 1 .......................................................................................... 1 Indicaii metodice pentru unitatea de nvare nr. 1 ................................................................... 1 Limbajul de programare S.......................................................................................................... 1 Noiunea de funcie calculabil .................................................................................................. 3 Macroinstruciuni n limbajul S ................................................................................................. 4 Tema de autoinstruire nr. 1 ........................................................................................................ 9 Testul de autoevaluare nr. 1 ....................................................................................................... 9 Comentarii i rspunsuri la testul nr. 1 de autoevaluare........................................................... 10 Lucrare de verificare pentru studeni ....................................................................................... 10 Bibliografie .............................................................................................................................. 11

1.1.

Obiectivele unitii de nvare nr. 1

Dup ce vei parcurge aceast unitate de nvare, vei reui s: cunoatei instruciunile limbajului S, precum i noiunea de macroinstruciune; nelegei noiunea de funcie calculabil.

1.2.

Indicaii metodice pentru unitatea de nvare nr. 1

Materialul trebuie parcurs n ordinea sa fireasc, prezentat n continuare. Se recomand conspectarea i notarea ideilor principale, precum i consultarea bibliografiei pentru detalii i informaii suplimentare. Timpul minim pe care trebuie s-l acordai acestei uniti de nvare este de ore.

1.3.

Limbajul de programare S

Un program P scris n limbajul S este o secven de instruciuni (un numr finit de instruciuni scrise ntr-o anumit ordine), program n care intervin: - numere naturale - variabile de intrare, notate de obicei prin x1 , x2 ,... - variabila de ieire y - variabilele intermediare (de lucru), notate de obicei prin z1 , z2 ,... cu meniunea c valorile luate de variabile pot fi orice numere naturale.

Deoarece lucrm numai cu numere naturale, vom spune uneori pur i simplu numr n loc de numr natural. nainte de a prezenta instruciunile limbajului S , precizm c ele pot fi precedate, opional, de etichete. Acestea sunt reprezentate prin litere mari (eventual indexate cu numere naturale), cuprinse ntre paranteze i plasate la nceputul instruciunii. Se admite ca mai multe instruciuni s aib aceeai etichet; raiunea acestui fapt va fi prezentat n capitolul 4. Instruciunile admise i semnificaia lor sunt urmtoarele:

v v +1 v v 1

Valoarea curent a variabilei v crete cu o unitate. Valoarea curent a variabilei v scade cu o unitate (dac era pozitiv), respectiv rmne 0 (dac era 0).

Dac valoarea curent a variabilei v este nenul, atunci se face transfer necondiionat la prima instruciune din program etichetat if v 0 goto L cu L ; dac nici o instruciune nu este etichetat cu L , atunci programul se termin. Dac valoarea curent a lui v este 0, atunci se trece la instruciunea urmtoare.
vv

Este instruciunea de efect nul, a crei utilitate va aprea ulterior .

Exemplul 1. Programul:

[ A] x x 1 y y +1 if x 0 goto A
se termin pentru orice valoare iniial a lui x . La ieire vom avea:

1,dac = 0 y= ,dac > 0

Exemplul 2. Programul:

[ A] x x + 1 if x 0 goto A
nu se termin niciodat, indiferent de valoarea iniial a lui x . Observaie. Faptul c programele n limbajul S produc o singur valoare de ieire nu este o restricie. ntr-adevr, dac dorim s obinem mai multe valori de ieire, vom scrie cte un program pentru fiecare i vom executa succesiv aceste programe. Menionm c, n acest studiu, suntem interesai numai de existena algoritmilor, nu i de eficiena lor.

1.4.

Noiunea de funcie calculabil

Fie P un program scris n limbajul S . Fie V mulimea tuturor variabilelor (de intrare, de lucru i de ieire) ce apar n P . Definim starea programului la un moment oarecare a executrii sale ca fiind o funcie s : V N , unde N este mulimea numerelor naturale. Deci o stare este dat de valorile curente ale variabilelor din program. O configuraie a programului P de lungime n (avnd n instruciuni) este o pereche (i, s) cu i { 1, 2,..., n, n + 1 } i s stare. O configuraie iniial are forma (1, s0 ) , unde:

r , dac u = xi i ri este valoarea iniial a lui xi s0 (u ) = i 0, dac u nu este o variabil de intrare

O configuraie terminal are forma (n + 1, s ) . Vom asimila transferul la o etichet inexistent cu transferul la instruciunea cu numrul n + 1 . Fie (i, s) o configuraie neterminal. Succesoarea ei ( j, t ) este definit astfel: 1) Dac instruciunea i este v v + 1 , atunci j = i + 1 , iar:

u, dac u v t (u) = u + 1, dac u = v

2) Dac instruciunea i este v v 1 , atunci j = i + 1 , iar:

s(v) 1, dac u = v i s(v) > 0 t (u) = s(v), n caz contrar

3) Dac instruciunea i este v v , atunci j = i + 1 i t = s . 4) Dac instruciunea i este if v 0 goto L , atunci t = s , iar:
i + 1, dac s (v ) = 0 j = n + 1, dac s (v ) 0 i nu exist vreo instruciune etichetat cu L k , dac s (v ) 0 i instruciunea k este prima etichetat cu L

Se observ c succesoarea oricrei configuraii neterminale este unic determinat i nu depinde de eventuala etichetare a sa.

Un calcul al programului P este o secven de configuraii consecutive c0 , c1 ,..., ck cu c0 configuraie iniial i ck configuraie final (terminal). Fie P un program n care variabilele de intrare sunt x1,...xm . Atunci funcia (parial)
( m) : N m N definit astfel: calculat de programul P este P

(m) ( x1,..., xm ) = y dac exist un calcul c0 , c1,..., ck al lui P cu c0 = (1, s0 ) i sk ( y) = y ; 1) P ( m) ( x1 ,..., xm ) = (nedefinit) dac exist un ir infinit de configuraii c0 , c1 ,... al lui P cu 2) P

c0 = (1, s0 ) (deci dac programul P nu se termin). Observaie. Fie P un program n care apar variabilele de intrare x1,...xm . Pentru orice n
(n) astfel: natural, i putem asocia o funcie P

(n) ( m) ( x1 ,..., xn ) = P ( x1,..., xm ) , adic xn +1 ,..., xm sunt ignorate; dac n m , atunci P (n) ( m) ( x1 ,..., xn ) = P ( x1,..., xm , 0,...0) . dac n > m , atunci P

Fie f : N m N . Funcia f se numete parial calculabil dac exist un program P n

( m) = f . Dac Dom f = N m , atunci f se numete calculabil. limbajul S cu P

Exemplul 1 de mai sus arat c funcia f : N N dat de:

1, dac x = 0 f ( x) = x, dac x>0

este calculabil. 1.5. Macroinstruciuni n limbajul S

Macroinstruciunile sunt abrevieri pentru secvene de instruciuni n limbajul S . Menirea lor este de a scrie programe ct mai inteligibile. Prezena unei macroinstruciuni ntr-un program trebuie interpretat ca prezena n acel punct al programului a unei dezvoltri a sale. Chiar dac n acelai program apare n diferite locuri o aceeai macroinstruciune, aceasta nu nseamn c va fi inserat aceeai dezvoltare a sa. Mai mult, chiar impunem ca apariiile unei aceleai macroinstruciuni pe poziii diferite din program s presupun dezvoltri diferite ale macroinstruciunii (variabile de lucru i etichete distincte). De asemenea, trebuie respectat regula ca valoarea variabilelor care apar n macroinstruciune, cu excepia celor care apar n membrul stng al unei atribuiri, s nu fie modificate ca efect al executrii macroinstruciunii. 1) Macroinstruciunea goto L are urmtoarea dezvoltare posibil: [A] z z + 1 if z 0 goto A 2) Macroinstruciunea v 0 are dezvoltarea: [A] v v 1 if v 0 goto A
4

unde eticheta A nu mai apare nicieri n programul ce conine aceast macroinstruciune. S remarcm faptul c variabilele locale dezvoltrii unei macroinstruciuni sunt presupuse a avea iniial valoarea 0, ca orice variabil de lucru. Totui, n cadrul dezvoltrii trebuie n general s le atribuim mai nti valoarea 0 (cu excepia cazului n care suntem siguri c dup executarea macroinstruciunii valoarea variabilelor locale va fi egal cu 0), deoarece macroinstruciunea poate apare n program n cadrul unui ciclu. 3) Macroinstruciunea v k are dezvoltarea:

v0 v v +1 ... v v +1
unde instruciunea v v + 1 apare de exact k ori. Exemplul 3. Funcia f : N N dat de f ( x) = x este calculabil. Vom demonstra acest fapt
(1) = f , program ce va asigura pstrarea valorii iniiale a lui x : scriind un program P cu P

[A] if x 0 goto B goto C [ B] x x 1 y y +1 z z +1 goto A [C ] if z 0 goto D goto E [ D] z z 1 x x +1 goto C unde primele 6 instruciuni copiaz valoarea lui x n variabilele y i z , iar urmtoarele recopiaz valoarea lui z n x . Putem acum introduce macroinstruciunea v u cu dezvoltarea: v0 [ A] if u 0 goto B goto C [ B] u u 1 v v +1 z z +1 goto A [C ] if z 0 goto D goto E [ D] z z 1 u u +1
5

goto C [E] v v Se impun urmtoarele trei remarci: 1. nu am iniializat pe z cu 0, deoarece este clar c dup orice executare a macroinstruciunii, valoarea sa va fi 0; 2. apare necesitatea instruciunii v v ; 3. ca de obicei, variabila z nu mai apare nicieri n program (este o variabil de lucru "nou"), iar etichetele A, B, C, D, E nu mai apar nicieri n program (sunt etichete "noi"). Avnd convingerea c cititorul s-a obinuit deja cu aceste reguli, nu le vom mai repeta n continuare, presupunndu-le subnelese. Exemplul 4. Funcia f : N N N definit prin f ( x1 , x2 ) = x1 + x2 este calculabil. Un program care calculeaz aceast funcie este urmtorul: y x1 z x2 [ B ] if z 0 goto A goto E [ A] z z 1 y y +1 goto B iar macroinstruciunea z z1 + z2 are urmtoarea dezvoltare posibil: u z1 v z2 [ B ] if v 0 goto A goto E [ A] v v 1 u u +1 goto B [E] z u Exemplul 5. Funcia f : N N N definit prin f ( x1 , x2 ) = x1 x2 este calculabil, iar macroinstruciunea z z1 z2 are urmtoarea dezvoltare posibil:

u 0 v z2 [ B ] if v 0 goto A goto E [ A] v v 1 u u + z1 goto B [E] z u

6

Exemplul 6. Fie f : N N N funcia parial definit prin:

x1 x2 , dac x1 x2 f ( x1, x2 ) = , dac x1 < x2

Un program care calculeaz aceast funcie este urmtorul: y x1 z x2 [C ] if z 0 goto A goto E [ A] if y 0 goto B {y = 0 i z 0 } goto A [ B] y y 1 z z 1 goto C Macroinstruciunea asociat este z z1 z2 i are urmtoarea dezvoltare posibil: u1 z1 u2 z 2 [C ] if u2 0 goto A goto E [ A] if u1 0 goto B goto A [ B ] u1 u1 1 u2 u2 1 goto C [ E ] z u1 Exemplul 7. Fie f : N m N o funcie (parial) calculabil), calculat de un program P . Vom introduce macroinstruciunea z f ( z1 ,..., zm ) . Pentru a obine o dezvoltarea a acestei macroinstruciuni, s presupunem c n programul P variabilele de intrare sunt x1 ,..., xm , variabilele de lucru sunt z1 ,..., zk , iar etichetele sunt

A1,..., Ap , unde (cu eventuala excepie a lui Ap ), orice etichet ce apare ntr-o instruciune if este eticheta a cel puin uneia dintre instruciunile din P . Atunci o dezvoltarea a macroinstruciunii z f ( z1 ,..., zm ) este urmtoarea: y 0 x1 x1 ... xm xm z1 0
7

...

zk 0 P I
unde:
z y , dac eticheta Ap este definit I este una dintre instruciunile [ Ap ] z y , altfel y, x1 ,..., xm , z1,..., zk sunt variabile de lucru noi;
A1 ,..., Ap sunt etichete noi;

se

obine

din

nlocuind

pe

y, x1 ,..., xm , z1,..., zk , A1 ,..., Ap

cu

y , x1 ,..., xm , z1 ,..., z k , A1 ,..., Ap .

Se observ imediat c dac pentru anumite valori iniiale r1 ,..., rm ale lui x1 ,..., xm programul P nu se termin, atunci nici executarea macroinstruciunii z f ( z1 ,..., zm ) nu se termin pentru z1 ,..., zm avnd, nainte de executarea macroinstruciunii, valorile r1 ,..., rm . Dac o macroinstruciune dintr-un program nu se termin, atunci nici programul care o folosete nu se termin. Numim predicat o funcie f : N m {0,1}, parial sau total definit, unde 0 corespunde falsului, iar 1 corespunde adevrului. Exemplul 8. Fie P : Nm {0,1} un predicat calculabil. Atunci putem introduce macroinstruciunea: if P( x1 ,....xm ) goto L a crei dezvoltare este: z P ( x1 ,..., xm ) if z 0 goto L Un caz particular l constituie predicatul:

1, dac x = 0 P( x ) = 0, dac x 0 care este calculabil conform programului:

if x 0 goto E y y +1 ceea ce permite introducerea urmtoarei macroinstruciuni:

if v = 0 goto L .
8

1.6.

Tema de autoinstruire nr. 1

Consultai bibliografia pentru: 1. a cunoate alte exemple de funcii calculabile; 2. a cunoate alte exemple de macroinstruciuni n limbajul S.

1.7.

Testul de autoevaluare nr. 1

Rspunsurile la test se vor da n spaiul liber aflat n continuarea enunurilor!

1. Fie urmtorul program P scris n limbajul S:

[ A] x1 x1 1 y y +1 if x1 0 goto A [ B] x2 x2 1 y y +1 if x 2 0 goto B
Indicai valoarea pe care o va avea variabila de ieire y la sfritul executrii programului, n fiecare din urmtoarele cazuri: a) x1 = 7, x2 = 3 b) x1 = 0, x2 = 0 c) x1 = 0, x2 = 5 d) x1 = 4, x2 = 0

2. Determinai funcia calculat de urmtorul program scris n limbajul S:

[ A] x1 x1 1 x2 x2 1 if x 2 0 goto A [ B ] x1 x1 1 y y +1 if x1 0 goto B 3. Demonstrai c funcia f : N N N definit prin f ( x1 , x2 ) = x1 x2 este calculabil, scriind programul corespunztor n limbajul S.

Rspunsurile la acest test se gsesc pe pagina urmtoare!

9

1.8.

Comentarii i rspunsuri la testul nr. 1 de autoevaluare

1. a) 10 b) 2 c) 6 d) 5

x1 x2 , dac x1 > x2 ( 2) ( x1 , x2 ) = 2. P 1, dac x1 x2 3. z x2 [ B ] if z 0 goto A goto E [ A] z z 1 y y + x1 goto B

1.9.

Lucrare de verificare pentru studeni

1. Fie urmtorul program P scris n limbajul S: z x2 [ B ] if z0 goto A goto E [ A] z z 1 y y + x1 goto B

Indicai valoarea pe care o va avea variabila de ieire y la sfritul executrii programului, n fiecare din urmtoarele cazuri: a) 0, 7 b) 3, 8 c) 12, 2

2. Determinai funcia calculat de urmtorul program scris n limbajul S: [ A] x1 x1 1 y y +1 if x1 0 goto A [ B] x2 x2 1 y y +1 if x 2 0 goto B 3. Considernd definite macroinstruciunile , i , demonstrai faptul c funcia : , , 1 este calculabil, scriind un program P n ( 2) limbajul S astfel nct P = f.

Rezolvrile, dar i dificultile ntmpinate, vor fi expediate prin email tutorelui.

10

1.10. Bibliografie

1. C. Calude "Complexitatea calculului aspecte calitative", Editura tiinific i Enciclopedic, 1962. 2. M.D. Davis, R. Sigal, E.J. Weyuker "Computability, Complexity and Languages", Academic Press (Morgan Kaufmann), 1994. 3. N.D. Jones "Computability and Complexity", MIT Press, 1997. 4. Christos H. Papadimitriou "Computational Complexity", Addison-Wesley, 1994. 5. C.P. Popovici, S. Rudeanu, H. Georgescu "Bazele informaticii", Vol.II, Tipografia Universitii Bucureti, 1991.

11