Metode de proiectare a algoritmilor (de elaborare a programelor)

1. C_6 / 9.11.07 • Metode de proiectare a algoritmilor • (de elaborare a programelor) • Rafinare in pasi succesivi • Programare Procedurala • Programare Structurata • Programare Top_Down – Bottom_Up • Programare Modulara • Programare Orientata Obiect • … componente, evenimente, …

2. Rafinare in pasi succesivi – Stepwise Rafinament Rafinare la nivel micro (descompunerea unui modul - subprogram). Top-Down : la nivel macro.În aceste versiuni succesive apar multe enunţuri nestandard ce urmează a fi precizate treptat prin propoziţii standard. Se recomandă ca ele să rămână comentarii în versiunea finală. Algoritmul apare în versiuni succesive, tot mai complet de la o versiune la alta. În versiunea finală în algoritm apar numai propoziţii standard. Un proces de detaliere pas cu pas a specificaţiei, denumit proiectare descendentă. Algoritmul apare în diferite versiuni succesive, fiecare fiind o detaliere a versiunii precedente. Succesiune de versiuni intermediare, o versiune se obtine prin rafinare a uneia precedent: P0  P1  …  Pn La nivel micro se doreşte obţinerea unui modul în versiune finală. Într-o versiune intermediară pot fi prezente numai părţile importante ale acestuia, urmând să se revină asupra detaliilor în versiunile următoare, după ce aspectele importante au fost rezolvateSe amana detaliile neseminficative, concentrandu-ne la problemele (partile) importante.

3. Programare procedurală Paradigmăîn programare, stil în programare prin care un program apelează subprograme (functii si proceduri, pentru a rezolva subprobleme) prin transmiterea corespunzatoare a parametrilor (actuali, aflati în corespondentă cu parametrii formali descrisi in subprograme). Programare structurată • Disciplinăîn programare prin folosirea unor structuri bine precizate (fără Goto). Orice problemă se poate descrie doar prin utilizarea următoarelor trei structuri: • secventială • alternativă, • repetitivă.

4. Exemplu: Rez. Sistem Arborele de programare: Principal Cit.Sist. Sistem Tip.Sist. Reduce Rezolva Date Calcul Rezultate Cit.Sist. Sistem Tip.Sist. S1 S2 S3 Programare Top_Down – Metoda descendentă Urmăreste (la nivel macro) descompunerea unei probleme complexe în subprobleme. Avantajul principal: permite programatorului să reducă complexitatea problemei, subproblemele în care a fost descompusă fiind mai simple, şi să amâne detaliile pentru mai târziu. În momentul în care descompunem problema în subprobleme nu ne gândim cum se vor rezolva subproblemele ci care sunt ele şi conexiunile dintre ele.   Proiectarea descendentă permite lucrul în echipe mari. Prin descompunerea problemei în mai multe subprobleme, fiecare subproblemă poate fi dată spre rezolvare unei subechipe. Fiecare subechipă nu cunoaşte decât subproblema pe care trebuie să o rezolve.

5. Pr. S1 S2 S3 S21 S22 S23 Programare Bottom-Up – Metoda ascendentă Utilizând propoziţiile limbajului şi subalgoritmi existenţi, îi asamblează în alţi subalgoritmi pentru a ajunge în final la algoritmul dorit. Deci, va fi scris mai întâi subalgoritmul apelat şi apoi cel care apelează. Ca rezultat al proiectării ascendente se ajunge la o mulţime de subalgoritmi care se apelează între ei. Este important să se cunoască care subalgoritm apelează pe care, lucru redat printr-o diagramă de structură, ca şi în cazul programării descendente.    Această metodă are marele dezavantaj că erorile de integrare vor fi detectate târziu, abia în faza de integrare. Se poate ajunge abia acum la concluzia că unii subalgoritmi, deşi corecţi, nu sunt utili.     De cele mai multe ori nu se practică o proiectare ascendentă sau descendentă pură ci o combinare a lor, o proiectare mixtă: Top_Down & Bottom-Up.

6. Programare Modulară – Modul Prin proiectare (programare) modulară înţelegem metoda de proiectare (programare) a unui algoritm pentru rezolvarea unei probleme prin folosirea modulelor. Modulul este considerat o unitate structurală de sine stătătoare, fie program, fie subprogram, fie o unitate de program. Un modul poate conţine sau poate fi conţinut într-alt modul si poate fi format din mai multe submodule. Este important ca fiecare modul să-şi aibă rolul său bine precizat, să realizeze o funcţie în cadrul întregului program (proiect). În limbajele de programare cu structură de bloc (de exemplu în Turbo Pascal, ) Unit-urile pot fi considerate module. La compilarea separată un grup de subprograme compilate deodată constituie un modul, dar acest modul poate fi considerat ca o mulţime de submodule din care este compus. Modulele sunt relativ independente,  dar cu posibilităţi de comunicare între ele. Astfel, un modul nu trebuie să fie influenţat de maniera în care se lucrează în interiorul altui modul. Orice modificare ulterioară în structura unui program, dacă funcţia pe care o realizează un modul M încă este necesară, acest modul trebuie să fie util şi folosit în continuare fără modificări.

7. … Programare Modulară – Modul •     Programarea modulară se bazează pe descompunerea problemei în subprobleme şi proiectarea şi programarea separată a subalgoritmilor corespunzători. Programarea modulară este strâns legată de programarea ascendentă şi de programarea descendentă, ambele presupunând folosirea subalgoritmilor pentru toate subproblemele întâlnite. • Avantajele programării modulare: • Descompunerea unei probleme complexe în subprobleme este un mijloc convenabil şi eficient de a reduce complexitatea. • Testarea unui modul se poate face mult mai uşor decât testarea întregului algoritm. • Permite munca mai multor programatori. S-a ajuns astfel la munca în echipă, prin care se ajunge la scurtarea termenului de realizare a produsului program. • Modulele se pot refolosi ori de câte ori avem nevoie de ele. Astfel, s-a ajuns la compilarea separată a subprogramelor şi la păstrarea subprogramelor obţinute în biblioteci de subprograme, de unde ele se pot refolosi la nevoie. • Reutilizabilitatea acestor subprograme duce la mărirea productivităţii în programare, dar şi la creşterea siguranţei în realizarea unui produs corect. •  Permite înlocuirea modulului în incorect cu altul mai performant. • Modulele se pot verifica mai uşor. Se pot înţelege şi poate analiza mult mai usor avand texte scurte.

8. C_6 / 9.11.07 • Tipuri abstracte de dată • Tip Abstract de dată • Programare Modulară • Modul în Pascal=Unit

9. Tip abstract de dată Tipul abstract de date (Tad): mulţime de valori, D, care formează domeniul tipului, împreună cu o mulţime de operatori pe acest domeniu. Tad este definit (de ) în urma unui proces de abstractizare, precizat prin: - domeniul Tad este precizat ca o mulţime matematică, D; - operatorii definiţi în acest domeniu. Valorile pentru care operaţia o are sens satisfac un predicat φ numit precondiţie pentru operaţia o. Rezultatul efectuării operaţiei o depinde de operanzi, este legat de aceşti operanzi, legătură precizată cu ajutorul unei postcondiţii, dată printr-un predicat ψ.

10. Operaţii : Un tip abstract de date trebuie să conţină suficiente operaţii pentru a fi util. El trebuie să permită creareaoricărei valori din domeniul tipului. Trebuie să existe suficiente operaţii de testare pentru a putea fi verificate toate precondiţiile operaţiilor. Trebuie concepute suficiente operaţii pentru ca programatorul să aibă acces la oricare din componentele din care e compus acest tip abstract de date. Deci tipurile de operaţii pe care le conţine un Tad sunt: - operaţii de intrare-ieşire; - operaţii de construire de valori din domeniul tipului; - operaţii de conversie (de valori din alte tipuri) în valori de acest tip; - operaţii de testare a unor condiţii; - operaţii de selectare a unor componente ale acestui tip de date.

11. Exemplu:Tadnumăr raţionalQ: Domeniul : mulţimea numerelor raţionale, notată prin Q : Q = {(m,n) | mZ, nN+, (m,n)=1}. Operaţii: Operaţia "Adun(q1,q2,q)": { q := q1 + q2 } Precondiţia: q1, q2  Q ; Postcondiţia: q = q1 + q2 . Operaţia "Scad(q1,q2,q)": { q := q1 - q2 } Precondiţia: q1, q2  Q ; Postcondiţia: q = q1 - q2 . Operaţia "Inmult(q1,q2,q)": { q := q1 * q2 } Precondiţia: q1, q2 Q ; Postcondiţia: q = q1*q2. Operaţia "Divid(q1,q2,q)": { q := q1 : q2 } Precondiţia: q1, q2  Q şi q2≠0; Postcondiţia: q = q1/q2.

12. Operaţii: Operaţia "Atribc(sus,jos,q)"; { q:= sus/jos} Precondiţia: sus  Z, jos  N şi jos≠0; Postcondiţia: q = sus/jos. Operaţia "Citeste(q)"; {q:= număr raţional citit} Precondiţia: se introduce ca pereche (numărător, numitor). Postcondiţia: q = numărul raţional citit. Operaţia "Tipareste(q)"; { Se afişează numărul q} Precondiţia: q  Q Postcondiţia: se afişează pe ecran numărul q Relaţia "Estezero(q)"; { Este q egal cu zero ?} Precondiţia: q  Q Postcondiţia: Estezero= (q=0) Relaţia "Egal(q1,q2)"; { Este q1 egal cu q2 ?} Precondiţia: q1, q2  Q Postcondiţia: Egal= (q1=q2) Relaţia "Maimare(q1,q2)"; { Este q1 mai mare decât q2 ?} Precondiţia: q1, q2  Q Postcondiţia: Maimare = (q1>q2) Funcţia "Intreg(q)"; { Partea întreagă a lui q} Precondiţia: q Q Postcondiţia: Intreg = [q]. // … Numarator, Numitor (Get,Set), Inv,…

13. Avantajele folosirii tipurilor abstracte de date: • specificarea exactă, • independenţa implementării, • ascunderea informaţiei, • simplitate şi integritate. • Prin abstractizare ne putem concentra asupra proprietăţilor esenţiale şi nu asupra reprezentării şi implementării; accentul cade asupra specificării tipului abstract de date. • Utilizatorul se va folosi doar de această specificare, el nu vede reprezentarea şi nici modul de implementare a operaţiilor. • Tipurile abstracte de date constituie unul din mijloacele care permit o abordare sistematică şi prin a căror utilizare se ajunge la realizarea unor module corecte şi refolosibile. • Mai mult, aceste module se pot organiza în biblioteci utile, ducând la creşterea productivităţii în programare.

14. Module (Unităţi de program în) Pascal : Prin modul - unitate de program (Unit) Pascal înţelegem o grupare de declaraţii (constante, tipuri, variabile şi subprograme) şi eventual o secţiune de iniţializare. Un modul (unit) este compus dintr-o parte de interfaţă (Interface) şi una de implementare (Implementation). Interfaţa constă din acele elemente ale unităţii care sunt disponibile (vizibile) în exterior. Partea de implementare nu este accesibilă în afara unităţii şi ea constă din constante, tipuri de date, variabile, funcţii, proceduri şi instructiuni (toate acestea fiind locale) care sunt referite în funcţiile şi procedurile descrise în interfaţă. Ea este invizibilă din alte unităţi de program.

15. Structura unui modul (Unit) : Forma generală a unei unităţi este următoarea : Unit<Nume_Unitate>; Interface <Listă_declaraţii_globale> Implementation <Listă_declaraţii_locale> [ Begin {opţională} <Secvenţă_de_iniţializare> ] End. În Interface se definesc constante, tipuri de dată, variabile, funcţii şi proceduri, accesibile altor unităţi care folosesc această unitate de program. În aceste unităti, elementele declarate în secţiunea Interface devin globale, putând fi folosite ca orice variabile globale dintr-un program Pascal, spre deosebire de elementele declarate în secţiunea Implementation, acestea fiind locale şi nefiind accesibile din afara unităţii. Secvenţa de iniţializare conţine instrucţiuni care vor fi executate implicit înaintea programului principal în scopul unor iniţializări.

16. Utilizarea (referirea) unui modul (Unit) : Un program sau o unitate de program care doreşte să folosească un Unit trebuie să precizeze acest lucru printr-o declaraţie de forma: Uses <Listă_unităţi_utilizate>; • Pe lângă unităţile de program pe care le scrie utilizatorul, acesta mai poate folosi câteva unităţi standard oferite de mediul Turbo Pascal. Menţionăm următoarele unităţi: • System - conţine proceduri şi funcţii de bază, predefinite, din Turbo Pascal (este inclusă automat în orice program, fără a mai fi necesară clauza Uses); • Crt - conţine constante, funcţii, proceduri, etc. de lucru cu ecranul şi tastatura; • Graph - conţine constante, variabile, tipuri de dată, funcţii şi proceduri grafice; • Dos - conţine subprograme de lucru cu fişiere.

17.  Exemplu: Se apelează Unitul Rational pentru calculul unei expresii. Aici se poate vedea cât de simplă este realizarea unui astfel de program având la dispoziţie acest tip. În acest exemplul s-a reuşit ca operaţiile de intrare-ieşire să fie cele obişnuite ( Read / Write ). Program Numere__Rationale; { x+y y+z z+x } UsesRational; { E = ----- * ----- * ------ } Var x,y,z : Rationale; { x-y y-z z-x } Begin { x,y,z e Q (de forma p/q, q<>0) } Write (' x : '); Readln (x); Write (' y : '); Readln (y); Write (' z : '); Readln (z); Writeln (' E = ', ProdQ( ProdQ ( ImpcQ (AdunQ(x,y),ScadQ(x,y) ), ImpcQ (AdunQ(y,z),ScadQ(y,z)) ), ImpcQ (AdunQ(z,x),ScadQ(z,x)))); Readln End.

18.  Unit Rational; Interface Type Rationale = String [20]; Function AdunQ ( a,b : Rationale) : Rationale; Function ScadQ ( a,b : Rationale) : Rationale; Function ProdQ ( a,b : Rationale) : Rationale; Function ImpcQ ( a,b : Rationale) : Rationale; Function InversQ ( a : Rationale) : Rationale; Implementation Type Q = Record Numarator, Numitor : Integer End; Function Cmmdc (a,b:Integer) : Integer; { Alg. Euclid recursiv } Begin If b=0 Then Cmmdc := a Else Cmmdc := Cmmdc (b, a Mod b) End;

19. Function Cmmmc (a,b:Integer) : Integer; Begin Cmmmc := a*b Div Cmmdc (a,b) End; Procedure Simplific ( Var x : Q); Var p:Integer; Begin With x Do Begin p:=Cmmdc(Numarator,Numitor); If p>1 Then Begin Numarator:=Numarator Div p; Numitor :=Numitor Div p End; If Numitor<0 Then Begin Numarator:= - Numarator; Numitor := - Numitor End End End;

20. Procedure TransfQ ( s:Rationale; Var x : Q ); { String  Q } Var p,q:Integer; Begin With x Do Begin { s de forma ‘numarator/numitor’ , de ex. ’3/2’ } Val (s,Numarator,p); { p = poz. car ’/’ } Val (Copy(s,1,p-1),Numarator,q); Val (Copy(s,p+1,Length(s)-p),Numitor,q); If Numitor=0 Then Begin Write ('<',s,'>',' Numitor=0'); Readln End; Simplific (x) End End; Function TransfR ( x : Q ) : Rationale; { Q  String } Var m, n : String; Begin With x Do Begin Str (Numarator, m); Str (Numitor, n) End; TransfR:=m+'/'+n End;

21. Procedure TipQ ( x : Q ); { Tipareste (q) } Begin With x Do Write (Numarator,'/',Numitor); End; Function AdunQ ( a,b : Rationale) : Rationale; { a+b } Var x,y, z : Q; Begin TransfQ(a,x); TransfQ(b,y); {z:=x+y} With z Do Begin Numitor := Cmmmc (x.Numitor,y.Numitor); Numarator := x.Numarator * (Numitor Div x.Numitor)+ y.Numarator * (Numitor Div y.Numitor) End; Simplific(z); AdunQ:=TransfR(z) End; Function ScadQ ( a,b : Rationale ) : Rationale; { a-b } Var y:Q; Begin TransfQ(b,y); With y Do Numarator := -Numarator; { a+(-b)} b:=TransfR(y); ScadQ:=AdunQ (a,b) End;

22. Function ProdQ ( a,b : Rationale) : Rationale; { a*b } Var x,y, z:Q; Begin TransfQ(a,x); TransfQ(b,y); { z:= x*y } With z Do Begin Numarator := x.Numarator * y.Numarator; Numitor := x.Numitor * y.Numitor End; Simplific (z); ProdQ:=TransfR(z) End; Function InversabQ ( a : Rationale ) : Boolean; {Numarator <> 0} Var x:Q; Begin TransfQ(a,x); InversabQ:=x.Numarator<>0; End;

23. Function InversQ ( a : Rationale ) : Rationale; { m/n  n/m } Var x : Q; n : Integer; Begin TransfQ (a,x); With x Do Begin If InversabQ(a) Then Begin n := Numarator; Numarator:= Numitor; Numitor := n End; End; InversQ:=TransfR(x) End; Function ImpcQ ( a,b : Rationale) : Rationale; { a / b = a * 1/b} Begin If InversabQ (b) Then ImpcQ:=ProdQ (a,InversQ(b)) Else Write (' Operatie ilegala (:0) ') End; { Nu are secventa de initializare } End.

24. Teme:  • Tad Natural în precizie marită, pentru a calcula Cmmdc(a,b), apelând < , - : • Program Cmmdc_Natural_Marit; • Uses Prec_Mar; • Var a, b : Natural; • Begin • Write (' Dati a : '); Readln (a); • Write (' Dati b : '); Readln (b); { Date a,b; } • While a<>b Do { Cat_Timp a <> b Executa } • If MaiMic (a,b) Then b:=Dif(b,a) { Daca a<b Atunci b:=b-a } • Else a:=Dif(a,b); { Altfel a:=a-b } • Write (' Cmmdc = ',a); { Sf_Cat_Timp; } • Readln { Rezultate a; } • End. • TadIntreg în precizie marită. Z  N • TadPolinom cu coeficienti Complecsi pentru a calcula P(z).P  C • TadMultime de numere reale cu maxim 300 de elemente. P  C . . . C_6 / 9.11.2007