C_
This presentation is the property of its rightful owner.
Sponsored Links
1 / 24

Metode de proiectare a algoritmilor (de elaborare a programelor) PowerPoint PPT Presentation


  • 64 Views
  • Uploaded on
  • Presentation posted in: General

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, ….

Download Presentation

Metode de proiectare a algoritmilor (de elaborare a programelor)

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Metode de proiectare a algoritmilor de elaborare a programelor

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, …


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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ă.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

… 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.


Metode de proiectare a algoritmilor de elaborare a programelor

C_6 / 9.11.07

  • Tipuri abstracte de dată

  • Tip Abstract de dată

  • Programare Modulară

  • Modul în Pascal=Unit


Metode de proiectare a algoritmilor de elaborare a programelor

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 ψ.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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,…


Metode de proiectare a algoritmilor de elaborare a programelor

  • 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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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;


Metode de proiectare a algoritmilor de elaborare a programelor

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;


Metode de proiectare a algoritmilor de elaborare a programelor

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;


Metode de proiectare a algoritmilor de elaborare a programelor

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;


Metode de proiectare a algoritmilor de elaborare a programelor

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;


Metode de proiectare a algoritmilor de elaborare a programelor

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.


Metode de proiectare a algoritmilor de elaborare a programelor

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


  • Login