UNIVERSITATEA “ŞTEFAN CEL MARE” SUCEAVA Facultatea de Ştiinţe Economice şi Administraţie Publică Specializarea Asistenţă Managerială şi Secretariat, anul III Conf. univ. dr. Nicolae Morariu
METODE ŞI TEHNICI DE PROGRAMARE
2011
CUPRINS Introducere …………………………………………………………………………….….
3
Capitolul 1. Algorimi şi tehnici de reprezentare a algoritmilor ……......................
4
1.1. Algoritmi. Definiţie, exemple ……………....………………...................................... 1.2. Tehnici de reprezentare a algoritmilor ………………………….....……...….……… 1.2.1. Schema logică ………………………..................................................….……… 1.2.2. Pseudocodul...........................................................................................................
4 6 6 7
Capitolul 2. Metode şi tehnici de programare ……………………………...........…..
8
2.1. Stiva ...................................................………………………………………………. 2.2. Metoda Backtracking …………...................................................…………………... 2.3. Recursivitate................................................................................................................ 2.4. Algoritmi genetici şi programare evolutivă ……………………......................…….. 2.5. Elemente de teoria grafurilor.......................................................................................
8 8 11 11 12
Capitolul 3. Evoluţia limbajelor de programare ……………………………………. 16 3.1. Limbaje în cod maşină.….....................................................................................…... 3.2. Limbaje de asamblare …........................……………………………………………. 3.3. Limbaje de nivel înalt ……...................…………………………………………….. Probleme rezolvate ……........................................……………………………………… Probleme propuse ………............………………………………………………….…….
16 16 17 19 20
Capitolul 4. Consideraţii generale privind lexicul, sintaxa şi semantica unui limbaj de programare.................................................................................
22
4.1. Alfabetul şi vocabularul unui limbaj de programare................................................... 4.2. Traducerea programelor (translatoare)........................................................................ 4.3. Analiza textului sursă a unui program.…………....................................................… Probleme rezolvate …….……………............................................................................... Probleme propuse ……….………...........................................................................……..
22 24 24 26 27
Capitolul 5. Limbajul Visual Basic ……………….........................................………...
28
5.1. Programarea aplicaţiilor Windows ……..........……………………………………... 5.2. Proprietăţi şi metode ………..................................................................……………. 5.3. Utilizare Visual Basic din Excel ……...............................................……………….. 5.4. Variabile …................................................................................................................. 5.5. Operaţii de intrare /ieşire realizate cu funcţiile InputBox ( ) şi MsgBox ( )...............
28 29 31 35 38
2
5.6. Structuri de ramificare şi ciclare (luare decizii).......................................................... 5.6.1. Structuri de ramificare …………………………..................................……….. 5.6.2. Structuri de ciclare…...............................................…………………………… 5.7. Module şi proceduri ……………............................................................…………… 5.7.1. Proceduri subrutine ………………………………..........................…………... 5.7.2. Proceduri funcţii.................................................................................................. 5.8. Obiecte în Visual Basic …….............................................……………..................... 5.9. Referire celule dintr-o foaie de calcul tabelar în Visual Basic ……........................... 5.10. Gestionarea unui proiect …………......................………………………................. 5.11. Crearea şi extinderea meniurilor ...........................................................................… 5.12. Realizarea programului executabil pentru aplicaţie (proiect)….........................…... 5.13. Baze de date, Gestionarul de date, controlul Data, obiecte Set de înregistrări, SQL pentru interogarea bazelor de date............................................................................. Probleme rezolvate …………………………......................................………………….. Probleme propuse spre rezolvare...................................................................................…. Teste de verificare Cap. 5...................................................................................................
40 40 42 42 43 44 46 51 52 53 53 54 55 67 67
Capitolul 6. Tendinţe actuale şi viitoare privind tehnologiile de programare.….
72
6.1. Inteligenţa artificială distribuită................................................................................. 6.2. Definirea conceptului de agent................................................................................... 6.3. Clasificarea agenţilor................................................................................................. 6.4. Aplicaţii actuale ale agenţilor. Domenii de utilizare................................................. 6.5. Sisteme multi-agent. Definiţie, clasificare, arhitecturi.............................................. 6.6. Limbaje de comunicare între agenţi.......................................................................... Probleme rezolvate................................................................................................................. Probleme propuse...................................................................................................................
72 73 75 76 79 80 82 83
GLOSAR......................................................................................................................
84
Bibliografie…………………………………………………..………………………
87
3
INTRODUCERE Scopul cursului
Scopul cursului este prezentarea unor metode şi tehnici de programare precum şi introducerea în programarea calculatoarelor, plecând de la observaţia că marea majoritate a limbajelor de programare au la bază o serie de concepte comune. Obiective -
-
-
se defineşte noţiunea de algorim, sunt date exemple şi sunt prezentate tehnicile de reprezentare a algoritmilor: schema logică, pseudocodul; sunt prezentate metode şi tehnici utilizate în programare: metoda backtracking, recursivitatea, tehnica divide et impera, aspecte privind algoritmii genetici şi programarea evolutivă, elemente de teoria grafurilor; se va prezenta necesitatea limbajelor de programare, evoluţia lor, generaţiile de limbaje de programare, definirea şi construirea unui limbaj de programare, clasificarea limbajelor după diverse criterii şi selectarea limbajului potrivit tipului de problemă de rezolvat; se vor descrie succint fazele parcurse începând de la elaborarea unui program într-un limbaj de programare şi până la execuţia acestuia pe calculator se va prezenta limbajul Visual Basic, modul de utilizare şi inerfaţa cu produsul Excel; în ultima parte a cursului sunt prezentate tendinţele actuale şi de perspectivă privind tehnologiile de programare: conceptul de agent software, tehnologia de programare orientată agent.
Forma de evaluare (E – examen, C – colocviu/test final, LP – lucrări de control Stabilirea notei finale (procentaje)
E 4C 70%
- răspunsuri la examen/colocviu/lucrări practice - activităţi aplicative atestate/laborator/lucrări practice/ proiect etc. 30% - teste pe parcursul semestrului - teme de control -
4
Capitolul 1. Algorimi şi tehnici de reprezentare a algoritmilor Rezumat- Se defineşte noţiunea de algorim, sunt date exemple şi sunt prezentate tehnicile de reprezentare a algoritmilor: schema logică, pseudocodul. Algoritmi. Definiţie, exemple. 1. Un algoritm este metoda prin care se rezolvă o problemă. 2. Un algoritm este o succesiune finită de paşi care trebuie parcurşi pentru rezolvarea unei probleme. Pentru rezolvarea unei probleme pot exista mai multe metode de rezolvare. Pot fi puse şi probleme pentru care nu este cunoscut un algoritm de rezolvare, sau pentru care nu există un algoritm de rezolvare. În general, pentru rezolvarea unei probleme, trebuie avute în vedere următoarele elemente: - datele de intrare; - algoritmul pentru rezolvarea problemei; - datele de ieşire. Această precizare poate fi reprezentată schematic astfel: ALGORITM Date de intrare Date de ieşire Exemple de algoritmi Ex. 1. Rezolvarea ecuaţiei de gradul 2 ax2 + bx +c = 0 Succesiunea de paşi este următoarea: 1 Citeşte coieficienţii a, b, c 2 Calculează delta = b2 – 4ac 3 Dacă delta = 0 atunci calculează x1 = x2 = -b / 2a , afişează x1, x2 continuă cu pasul 6 4 Dacă delta > 0 atunci calculează x1 = (-b + SQRT(delta)) / 2a x2 = (-b - SQRT(delta)) / 2a afişează “x1=”, x1 ; “x2=”, x2 continuă cu pasul 6 5 Dacă delta < 0 atunci calculează Rx = -b / 2a ; Ix = SQRT(-delta) / 2a afişează “x1=”, Rx , “ + i“,Ix “x2=”, Rx , “ - i“,Ix 6 Continuaţi pentru o altă ecuaţie ? (DA, NU) 7 Dacă răspunsul este DA atunci se reia cu pasul 1 8 Dacă răspunsul este NU atunci STOP. S-a notat cu SQRT funcţia pentru radical. Algoritmul prezentat conţine atât ramificaţii (definite prin Dacă) cât şi un ciclu care poate fi identificat în paşii 6, 7.
5
Ex. 2. Iniţializarea fişei de pontaj lunar. La reali zarea unei aplicaţii de calcul salarii în VBA din EXCEL una din operaţiile care trebuie realizate la începutul fiecărei luni este ştergerea datelor din fişa de pontaj pentru luna precedentă (coloanele 1 – 34 începând din rândul 3 atâta timp cât există date în coloana 1) şi crearea fişei de pontaj pentru luna care urmează (copierea coloanelor 1 – 2 din foaia de calcul ANGAJATI în foaia de calcul PONTAJ începând din rândul 3 atâta timp cât există date în foaia de calcul ANGAJATI). Algoritmul corespunzător acestei operaţii este: ‘ Ştergere date din PONTAJ 1. rand = 3 2. Dacă PONTAJ(rand , 1) # “” (există date în rândul rand, coloana 1) Atunci Pentru k = 1 până la 34 PONTAJ(rand , k) = “” Continuă cu pasul 3 Altfel continuă cu pasul 4 3. rand = rand + 1 Continuă cu pasul 2 ‘ Creare fişa pontaj 4. rand = 3 5. Dacă ANGAJATI(rand , 1) # “”(există date în rândul rand, coloana 1) Atunci PONTAJ(rand , 1) = ANGAJATI(rand , 1) PONTAJ(rand , 2) = ANGAJATI(rand , 2) Continuă cu pasul 6 Altfel STOP 6. rand = rand + 1 Continuă cu pasul 5 Cele două foi de calcul sunt ilustrate în imaginile de ecran de mai jos.
6
1.2. Tehnici de reprezentare a algoritmilor Pentru reprezentarea algoritmilor au fost utilizate în ordine cronologică următoarele tehnici: schema logică, pseudocodul. 1.2.1. Schema logică Schema logică este o modalitate de reprezentare grafică a unui algoritm. Schema logică pentru algoritmul de rezolvare a ecuaţiei de gradul 2 este prezentată mai jos. START
Citeşte a, b, c delta = b2 – 4ac delta = 0
DA
NU DA
delta > 0 NU REALx = -b / 2a IMAGx = SQRT(-delta)) / 2a
x1 = (-b + SQRT(delta)) / 2a x2 = (-b - SQRT(delta)) / 2a
“x1=”,Rx “+i”,Ix “x2=”,Rx “-i”,Ix
“x1=”,x1 “x2=”,x2
DA
Continuaţi ? NU STOP
7
x = -b / 2a
“x1=”,x “x2=”,x
Din schema logică prezentată se constată utilizarea următoarelor tipuri de simboluri: - elipsă - pentru inceput algoritm, sfârşit algoritm; - trapez cu latura mare sus – pentru operaţii de intrare (preluare date, citire date); - dreptunghi – pentru operaţii de calcul; - romb – pentru operaţii de decizie (ramificaţii); - trapez cu latura mică sus – pentru operaţii de ieşire (afişare, scriere date, rezultate); - trimitere cu săgeată – pentru iteraţii ( cicluri). Dacă schema se întinde pe mai multe pagini, sau pentru reluări, se pot folosi trimiteri prin conectori (cerc numerotat în interior cu ieşire săgeată şi corespunzător intrare săgeată pt. acelaşi număr de cerc). 1.2.2. Pseudocodul Pseudocodul este o metodă de reprezentare a unui algoritm într-un limbaj pe de o parte mai apropiat de limbajul natural, iar pe de altă parte într-o formă care să permită transcrierea lui ulterioară într-un limbaj de programare. Această metodă de reprezentare a algoritmilor este derivată din limbajul ALGOL (ALGOrithmic Language) şi este bazată pe faptul că programele mari (pentru rezolvarea unor probleme complexe) sunt în general structurate pe componente numite module, fiecare modul reprezentând o funcţie distinctă pentru rezolvarea problemei. Pentru rezolvarea problemei se defineşte astfel o ierarhie de module între care există diverse legături (uneori un modul se poate apela pe el însuşi , lucru care este imposibil de reprezentat cu ajutorul schemei logice). Un algoritm descris în pseudocod traduce problema de rezolvat într-o succesiune de acţiuni numite operaţii sau instrucţiuni, fiecare instrucţiune reprezentând un pas al algoritmului. De asemenea trebuie evidenţiate structurile alternative şi structurile repetitive. Orice text care nu reprezintă un pas al algoritmului este o declaraţie sau un comentariu. Orice variabilă utilizată în cadrul algoritmului trebuie declarată anterior. Având în vedere aspectele prezentate, reprezentarea în pseudocod a algoritmului de iniţializare a fişei de pontaj este: Declară variabila rand ca întreg la nivel global ‘ Ştergere date din PONTAJ (comentariu) rand = 3 Cât timp PONTAJ(rand , 1) # “” Pentru k = 1 până la 34 PONTAJ(rand , k) = “” rand = rand + 1 ‘ Creare fişa pontaj (comentariu) rand = 3 Cât timp ANGAJATI(rand , 1) # “” PONTAJ(rand , 1) = ANGAJATI(rand , 1) PONTAJ(rand , 2) = ANGAJATI(rand , 2) rand = rand + 1
8
Capitolul 2. Metode şi tehnici de programare Rezumat - Sunt prezentate metode şi tehnici utilizate în programare: metoda backtracking, recursivitatea, tehnica divide et impera, aspecte privind algoritmii genetici şi programarea evolutivă, elemente de teoria grafurilor. 2.1. Stiva Stiva este o formă de organizare a datelor pentru care operaţiile de introducere şi scoatere a datelor se fac în vârful ei. Pentru a înţelege modul de lucru cu stiva considerăm un număr n de farfurii identice aşezate una peste alta. Adăugarea sau scoaterea unei farfurii se poate face numai în vârful stivei. Dacă toate cele n farfurii sunt aşezate una peste alta spunem că stiva este plină, iar după ce scoatem toate farfuriile din stivă spunem că stiva este vidă. Stiva poate fi reprezentată cu ajutorul unui vector ST(1), ST(2),...,ST(n), în care pot fi memorate numai litere sau numai cifre dacă fiecare element ST(i) al stivei memorează o singură informaţie (lăţimea stivei este 1). În cazul în care fiecare element al stivei memorează mai multe informaţii avem de a face cu stive duble, triple, etc. O variabilă k va indica în permanenţă vârful stivei. La extragerea unui element din stivă variabila k ce indică vârful stivei scade cu 1, iar la adăugarea unui nou element în stivă variabila k creşte cu 1. Operaţia de extragere din stivă se poate efectua până când stiva devine vidă, iar operaţia de adăugare în stivă se poate efectua până când stiva devine plină. B
ST(2) ST(1)
Stiva vidă
A
A
Vârful stivei k = 1
Vârful stivei k = 2
2.2. Metoda Backtracking Această metodă poate fi folosită la rezolvarea problemelor pentru care soluţia problemei poate fi pusă sub forma unui vector S(x1,x2,…,xn), unde x10 A1, x20 A2, … ,xn0 An, mulţimile A1, A2, … , An sunt finite şi elementele lor se află într-o relaţie de ordine bine stabilită şi pentru aceste probleme nu există o altă metodă de rezolvare mai rapidă. În multe probleme, mulţimile A1, A2, … , An coincid, iar x1,x2,…,xn pot fi la rândul lor vectori. Pentru rezolvarea unei probleme prin metoda backtracking se parcurge algoritmul prezentat mai jos. 1. Se alege primul element x10 A1. 2. Presupunând generate elementele x1,x2,…,xk, ale vectorului soluţie se alege xk+1, primul element disponibil din mulţimea Ak+1 care îndeplineşte condiţiile pentru soluţie. 3. Dacă nu s-a găsit elementul xk+1 care îndeplineşte condiţiile pentru soluţie, se reia căutarea considerând generate elementele x1,x2,…,xk-1, iar pentru xk, se verifică următorul element din mulţimea Ak.
9
4. Dacă s-a găsit elementul xk+1 care îndeplineşte condiţiile pentru soluţie, se verifică dacă s-au generat toate elementele soluţiei (k+1=n). 5. Dacă s-a ajuns la soluţie se tipăreşte soluţia şi se continuă algoritmul considerând generate elementele x1,x2,…,xk, (se caută un alt element al mulţimii Ak+1 rămas netestat). 6. Dacă nu s-a ajuns la soluţie se continuă algoritmul considerând generate elementele x1,x2,…,x k+1, (se caută un prim element xk+2 al mulţimii Ak+2). Algoritmul se termină atunci când nu mai există nici un element x10 A1 netestat. Metoda Backtracking conduce la obţinerea tuturor soluţiilor problemei. Dacă se cere obţinerea unei singure soluţii, se poate forţa oprirea algoritmului după găsirea primei soluţii. Pentru problemele în care soluţia este sub formă de vector (stiva este de lăţime 1) metoda este denumită backtracking elementar, iar pentru problemele în care stiva este dublă, triplă etc. metoda este denumită backtracking generalizat. În cele ce urmează se va prezenta un exemplu practic de utilizare a metodei. Problema comis-voiajorului Un comis-voiajor trbuie să viziteze un număr n de oraşe notate 1, 2, ..., n în următoarele condţii: pleacă din oraşul 1, trece prin toate oraşele o singură dată folosind legăturile existente între oraşe şi revine în final în oraşul 1. Se cere să se determine toate drumurile posibile pe care le poate parcurge comis-voiajorul. Pentru rezolvarea problemei se poate utiliza metoda backtracking elementar folosind o stivă ST(1), ST(2),...,ST(n) în care elementele ST(k) vor conţine numerele 1, 2, ..., n cu care sunt notate oraşele cu condiţia ca pentru nemerele memorate în două nivele succesive ale stivei să existe legătură între oraşele corespunzătoare şi ST(1) =ST(n) =1. Legăturile între oraşe pot fi reprezentate printr-o matrice L(i,j) astfel: 1 dacă există drum între oraşele i şi j L(i,j) = 0 dacă nu există drum între oraşele i şi j Exemplu
2
3
1
4 6
5
Drumurile posibile pe care le poate parcurge comis-voiajorul sunt: D1 = (1,2,3,4,5,6,1) D2 = (1,2,5,4,3,6,1) D3 = (1,6,3,4,5,2,1) D4 = (1,6,5,4,3,2,1) Tehnica Greedy Tehnica Greedy poate fi privită ca un caz particular al tehnicii backtracking în care se renunţă la mecanismul de întoarcere şi în plus se cere aflarea unei singure soluţii a 10
problemei, soluţie care satisface un anumit criteriu de optim. Tehnica Greedy conduce la timp de calcul polinomial (timp util), însă prezintă dezavantajul că pentru cele mai multe probleme nu se cunosc algoritmi de tip Greedy (pentru astfel de probleme se renunţă la optimalitate în favoarea găsirii unei soluţii în timp util). Un exemplu de astfel de problemă este problema comis-voiajorului pentru care un criteriu de optimalitate ar putea fi unul din următoarele: - timpul parcurgerii drumului să fie minim; - costul parcurgerii drumului să fie minim. O modalitate de rezolvare a acestei probleme este să determinăm toate drumurile posibile, să calculăm timpul respectiv costul parcurgerii fiecărui drum şi să alegem drumul optim (abordare care conduce la timp exponenţial de calcul). Pentru această problemă nu se cunosc algoritmi de tip Greedy. Problema rucsacului (exemplu de problemă pentru care există algoritm de tip Greedy) Cu un rucsac se poate transporta o greutate maximă G. Se pot transporta obiecte sau părţi ale acestora, pentru fiecare obiect fiind cunoscute greutatea sa şi câştigul care s-ar obţine în urma transportului său la destinaţie. Să se determine ce obiecte pot fi transportate astfel încât câştigul să fie maxim. Pentru rezolvarea problemei se utilizează următorul algoritm: 1. pentru fiecare obiect se calculează eficienţa de transport ca fiind rezultatul împărţirii căştigului la greutatea obiectului (se obţine câştigul obţinut prin transportul unităţii de greutate). 2. Se sortează obiectele în ordinea descrescătoare a eficienţei de transport şi se iau în calcul în această ordine. 3. Câştigul iniţial = o Greutatea rămasă de încărcat în rucsac = G. 4. Cât timp nu a fost completată greutatea G a rucsacului şi nu au fost luate în considerare toate obiectele se procedează astfel: - Dintre obiectele neâncărcate se selectează cel cu eficienţa de transport cea mai mare. - Dacă obiectul selectat încape în totalitate în rucsac - din G se scade greutatea obiectului - la câştigul iniţial se adună câştigul corespunzător obiectului - se tipăreşte 1 (semnifică faptul că întregul obiect a fost incărcat - Dacă obiectul selectat nu încape în totalitate în rucsac - se calculează ce parte din obiect poate fi transportată - la câştigul iniţial se adună câştigul corespunzător părţii de obiect - se tipăreşte partea care s-a incărcat din obiect - greutatea rămasă de încărcat devine 0. 2.3. Recursivitate Recursivitatea este o noţiune fundamentală utilizată în informatică după anii 80 pentru scrierea programelor în cadrul unor limbaje de programare evaluate. Acest concept 11
este utilizat în matematică pentru scrierea unor formule recursive, mai exact pentru definirea funcţiilor recursive. O funţie recursivă este o funcţie care se autoapelează. Recursivitatea este mecanismul prin care un subprogram (funcţie, procedură) se autoapelează. Acest mecanism mai este numit şi recursivitate directă, spre deosebire de recursivitatea indirectă care are loc atunci când o procedură (funcţie) apelează o altă procedură (funcţie), care la rândul ei o apelează pe ea. Pentru exemplificare dacă notăm cu F(n) n factorial = 1.2. … .n putem scrie F(n) = F(n – 1).n ceea ce înseamnă că în definirea funcţiei F de calcul a factorialului unui număr am utilizat recursivitatea. Dacă în cazul funcţiilor recursivitatea pare un mechanism simplu, nu la fel stau lucrurile în cazul algoritmilor şi deci al procedurilor recursive. Un algoritm recursiv trebuie să conţină o condiţie de terminare, altfel algoritmul nu se va termina niciodată şi deci nu va putea fi transcris într-un program pentru calculator. Pentru implementarea recursivităţii în cadrul limbajelor de programare care dispun de această facilitate se foloseşte structura de date de tip stivă care este gestionată de limbajul de programare şi nu de programator. S-a demonstrat matematic că pentru orice algoritm iterativ există un algoritm recursiv echivalent (rezolvă aceeaşi problemă) şi invers, pentru orice algoritm recursiv există un algoritm iterativ echivalent. Folosind recursivitatea în scrierea algoritmilor şi deci a programelor se obţine un text sursă foarte scurt şi clar, însă există situaţii când execuţia unui algoritm recursiv necesită un timp de calcul foarte mare, timp care poate fi redus considerabil dacă se utilizează un agoritm iterativ echivalent. Tehnica Divide et impera Tehnica divide et impera constă în descompunerea unei probleme în două sau mai multe probleme mai simplu de rezolvat, iar soluţia pentru problema iniţială se obţine prin combinarea soluţiilor problemelor rezultate prin descompunere. Fiecare din problemele rezultate prin descompunere pot fi la rândul lor descompuse în subprobleme mai simplu de rezolvat, procedeul putând continua pâna se ajunge la o descompunere în probleme care admit o rezolvare imediată. Pentru descrierea algoritmului de rezolvare prin metoda divide et impera se poate utiliza principiul recursivităţii. 2.4. Algoritmi genetici şi programare evolutivă Teoria matematică a calculului evolutiv cuprinde următoarele direcţii de cercetare: - algoritmii genetici; - strategiile de evoluţie şi programarea evolutivă. Algoritmii genetici sunt metode de căutare şi optimizare moderne, bazate pe principiile selecţiei naturale şi geneticii şi care acţionează asupra unei codificări a funcţiei obiectiv, efectuând operaţii de reproducere asupra unei populaţii de cromozomi, utilizând operatori genetici: selecţia, încrucişarea, inversiunea, mutaţia. Parametrii problemei sunt codificaţi printr-un şir de caracteristici binare analoge cromozomilor biologici. Fiecărui parametru ii corespunde un subşir în şirul cromozomial, subşirurile fiind numite gene. 12
Soluţiile sunt create prin selecţia şi combinarea cromozomilor existenţi urmărind optimizarea funcţiei obiectiv specifică problemei de rezolvat. Strategiile de evoluţie şi Programarea evolutivă – cunoscute şi sub denumirea de algoritmi evolutivi, pun accentul pe legătura comportamentală dintre părinţi şi urmaşi sau dintre diferite populaţii. Programarea evolutivă constă în estimarea modificărilor de mediu în vederea transformării predicţiilor într-un răspuns corespunzător acestor schimbări, în funcţie de scopul propus. Dacă simularea mediului constă dintr-o mulţime de simboluri ale unui alfabet finit, atunci prin programarea evolutivă se urmăreşte dezvoltarea unui algoritm care să opereze cu o secvenţă de simboluri deja observate astfel încât să producă un nou simbol care să maximizeze eficienţa algoritmului în raport cu următorul simbol din mediu şi care să optimizeze o anumită funcţie cost. O reprezentare adecvată a acestui comportament este dată de teoria automatelor finite. Pentru aplicarea programării evolutive asupra automatelor finite se parcurg următorii paşi: 1. Se construieşte aleator o populaţie de automate finite părinte; 2. Părinţii se expun mediului; 3. Se creează automate urmaşi prin mutaţii aleatoare ale fiecărei maşini părinte; 4. Se evaluează urmaşii în raport cu mediul în acelaşi mod ca şi părinţii; 5. Maşinile care produc costul minim se reţin drept părinţi pentru noua generaţie; 6. Se iterează paşii 3.-5. până ce se execută estimarea asupra noului simbol din mediu, estimare efectuată de cel mai bun automat. Noul simbol este adăugat listei de simboluri deja observate şi procesul se reia de la pasul 2. Un astfel de algoritm poate fi utilizat spre exemplu pentru generarea automată a unui program pentru rezolvarea unui tip de problemă. În timp ce strategiile evolutive se bazează pe selecţia strict deterministă, programarea evolutivă foloseşte selecţia probabilistă, iar în al doilea rând, în timp ce strategiile de evoluţie modelează structurile indivizilor, programarea evolutivă se ocupă de codificarea populaţiilor, deci a speciilor distincte. 2.5. Elemente de teoria grafurilor Fie o mulţime finită şi nevidă V = {x1, x2, … ,xn} numită mulţimea nodurilor sau a vârfurilor şi Eφ VxV ( E = {(xk,xp) / xk0 V, xp0 V}) o submulţime a produsului cartezian VxV numită mulţimea arcelor sau a muchiilor. Se numeşte graf, perechea ordonată G = (V,E). Pentru un arc u=(x,y), vârful x se numeşte extremitatea iniţială a arcului u, iar vârful y se numeşte extremitatea finală a arcului u. Mulţimea E are proprietatea de simetrie dacă şi numai dacă pentru orice pereche (xk,xp)0 E atunci (xp,xk)0 E (sau alfel spus orice arc poate fi parcurs în ambele sensuri). Dacă mulţimea E nu are proprietatea de simetrie atunci graful G se numeşte graf orientat sau graf antisimetric. Dacă mulţimea E are proprietatea de simetrie atunci graful G se numeşte graf neorientat sau graf simetric. 13
Un exemplu de graf neorientat este reţeaua rutieră a unei regiuni în care nodurile sunt localităţile din acea regiune, iar arcele sunt căile de comunicaţie rutieră între localităţi, presupunând că deplasarea este permisă în ambele sensuri. Un graf G = (V, E) se numeşte graf complet dacă între orice pereche de vârfuri există cel puţin un arc. Reţeaua telefonică a unui oraş este un exemplu de graf complet şi simetric. În reprezentare grafică, nodurile sunt figurate prin cerc sau pătrat iar arcele prin linie pentru graful neorientat şi linie cu săgeată pentru graful orientat. Un exemplu de reprezentare grafică pentru un graf neorientat este ilustrat la problema comis-voiajorului prezentată anterior. Una din metodele utilizate pentru memorarea unui graf constă în construirea matricii asociate grafului şi anume: 1 dacă există arc între nodurile xk şi xp A(k,p) = 0 dacă nu există arc între nodurile xk şi xp Pentru un graf neorientat (simetric) se constată că matricea asociată este simetrică. Pentru rezolvarea unor probleme de optim (minim sau maxim) se construieşte şi matricea costurilor ckp dacă există arc de cost ckp între nodurile xk şi xp C(k,p) = 0 dacă k = p +∞, - ∞ dacă nu există arc între nodurile x şi x k p Se numeşte drum de la vârful xk la vârful xp, şi se notează d(xk,xp) o succesiune de arce la fel orientate cu primul arc, cu proprietatea că extremitatea terminală a fiecărui arc coincide cu extremitatea iniţială a arcului următor, excepţie făcând extremitatea iniţială a primului arc şi extremitatea terminală a ultimului arc. Un drum de la vârful xk la vârful xp poate fi precizat astfel: d(xk,xp) = (xk, xk+1, … ,xp-1, xp) unde fiecare vârf al drumului se scrie o singură dată. Numărul arcelor pe care îl conţine drumul, în afara unor precizări speciale, se numeşte lungimea drumului. Un drum pentru care toate arcele din secvenţă sunt distincte sau care nu trece de două ori prin acelaşi arc se numeşte drum simplu. Un drum care are toate vârfurile distincte sau care nu trece de două ori prin acelaşi vârf se numeşte drum elementar. Un drum elementar care întâlneşte toate vârfurile grafului o singură dată se numeşte drum hamiltonian. Un drum cu proprietatea că extremitatea iniţială a primului arc coincide cu extremitatea terminală a ultimului arc se numeşte circuit. O buclă este un circuit de lungime 1. Se numeşte lanţ de la vârful xp la vârful xk o succesiune de muchii puse cap la cap (între două vârfuri există o muchie dacă între ele există cel puţin un arc; nu interesează orientarea arcelor). 14
Un lanţ care întâlneşte toate vârfurile grafului o singură dată se numeşte lanţ hamiltonian. Un lanţ finit care pleacă de la un vârf şi se întoarce la vârful cu care începe, adică este închis se numeşte ciclu. Necesitatea determinării traseelor hamiltoniene îşi are originea în soluţionarea unor probleme practice clasice, precum problema “comis-voiajorului”. Cercetarea acestor trasee prezintă interes în aplicaţii diverse din sfera economică: organizarea fluxurilor de producţie, transportul unor produse, transmitere de energie, aprovizionare etc. Există o serie de metode pentru determinarea drumurilor hamiltoniene printre care amintim algoritmul lui Kaufmann pentru determinarea drumurilor hamiltoniene în grafuri oarecare. În practica economică apar numeroase probleme a căror rezolvare presupune determinarea drumului optim. Pentru rezolvarea acestor probleme se defineşte şi utilizează în plus matricea costurilor prezentată anterior. Există algoritmi pentru rezolvarea unor probleme de optim (minim, maxim) ca de exemplu: algoritmul lui Bellman-Kalaba pentru probleme de minim, algoritm pentru probleme de maxim. În cele ce urmează este prezentată o metodă [11] de rezolvare a unei probleme de optim pentru o aplicaţie practică. Determinarea drumului hamiltonian minim Fiind date n localităţi, se pune problema determinării drumului minim care pleacă din localitatea 1 şi trece prin toate localităţile o singură dată (drumul hamiltonian minim într-un graf simetric). În exemplul ilustrat mai jos sunt reprezentate 6 localităţi (1, 2, 3, 4, 5, 6), căile rutiere existente între localităţi şi distanţele corespunzătoare. 11
2
6
3
7
13
1
5 8
4
9
6
4
3
15 5
Se construieşte matricea distanţelor astfel:
C1 1
C2 2
C3 3
C4 4
C5 5
C6 6
L1
1
0
6
0
0
0
8
L2
2
6
0
11
0
15
5
L3
3
0
11
0
7
3
13
L4
4
0
0
7
0
4
0
L5
5
0
15
3
4
0
9
L6
6
8
5
13
0 15 9
0
Pentru determinarea drumului minim se poate utiliza următorul algoritm: - Se selectează linia 1 şi se reţine coloana cu distanţa cea mai mică (exceptând valorile 0), respectiv coloana 2. Se elimină din matricea distanţelor linia 1 şi coloana 1. Rezultă tripleta (linia, coloana, distanţa) = (1, 2, 6) - Corespunzător coloanei 2 determinate în pasul anterior se selectează linia 2 şi se reţine coloana cu distanţa cea mai mică exceptând valorile 0), respectiv coloana 6. Se elimină din matricea distanţelor linia 2 şi coloana 2. Rezultă tripleta (linia, coloana, distanţa) = (2, 6, 5) - Corespunzător coloanei 6 determinate în pasul anterior se selectează linia 6 şi se reţine coloana cu distanţa cea mai mică exceptând valorile 0), respectiv coloana 5. Se elimină din matricea distanţelor linia 6 şi coloana 6. Rezultă tripleta (linia, coloana, distanţa) = (6, 5, 9) - Corespunzător coloanei 5 determinate în pasul anterior se selectează linia 5 şi se reţine coloana cu distanţa cea mai mică exceptând valorile 0), respectiv coloana 3. Se elimină din matricea distanţelor linia 5 şi coloana 5. Rezultă tripleta (linia, coloana, distanţa) = (5, 3, 3) - Corespunzător coloanei 3 determinate în pasul anterior se selectează linia 3 şi se reţine coloana cu distanţa cea mai mică exceptând valorile 0), respectiv coloana 4. Se elimină din matricea distanţelor linia 3 şi coloana 3. Rezultă tripleta (linia, coloana, distanţa) = (3, 4, 7) Algoritmul se termină deoarece singura linie şi coloană rămase neeliminate sunt linia 4 şi coloana 4 cu distanţa 0. Semnificaţia tripletelor rezultate este dată mai jos: Localitate Localitate Distanţa 1 2 6 2 6 5 6 5 9 5 3 3 3 4 7 Rezultă că drumul minim este: 1 - 2 - 6 - 5 - 3 - 4 iar distanţa minimă este: 6 + 5 + 9 + 3 + 7 = 30
16
Capitolul 3. Evoluţia limbajelor de programare Rezumat- se prezintă necesitatea limbajelor de programare, evoluţia lor, generaţiile de limbaje de programare, definirea şi construirea unui limbaj de programare, clasificarea limbajelor după diverse criterii şi selectarea limbajului potrivit tipului de problemă de rezolvat. Un limbaj de programare permite descrierea unui proces de calcul alcătuit din mai mulţi paşi pentru rezolvarea unei probleme, fiecare pas fiind exprimat în comenzi elementare (instrucţiuni) ce vor fi executate de calculator. 3.1. Limbaje în cod maşină Un calculator poate executa orice program descris în limbajul propriu, numit limbajmaşină. Limbajele în cod-maşină constituie prima generaţie de limbaje de programare,.sunt bazate pe sistemul binar şi diferă de la un calculator la altul. Fiecare instrucţiune în aceste limbaje este o succesiune de cifre binare. Limbajele în cod maşină au următoarele dezavantaje: - necesitatea descompunerii problemei de rezolvat în operaţii elementare pe care le poate executa calculatorul respectiv, cu specificarea codului numeric pentru instrucţiuni, date şi adrese de memorie; - lizibilitate scăzută şi o rată mare a erorilor; - dependenţa de un anumit tip de calculator; - dimensiune mare a programelor; - productivitate mică in activitatea de programare. Având în vedere aceste dezavantaje, s-a impus crearea unor limbaje artifciale care să permită descrierea modului de rezolvare a problemei într-o manieră apropiată de limbajul matematic sau economic sau chiar limbajul natural, care să necesite un efort minim din partea programatorilor şi să poată fi executate pe orice tip de calculator. 3.2. Limbaje de asamblare Pentru îndeplinirea unor deziderate mai sus menţionate, următoarea etapă după limbajele cod maşină o constituie apariţia limbajelor de asamblare care constituie a doua generaţie de limbaje de programare. Acestea necesită o cunoaştere aprofundată a calculatorului şi a sistemului de operare deoarece înlocuiesc codurile numerice ale instrucţiunilor şi operanzilor cu coduri mnemonice. Instrucţiunile diferă de la un calculator la altul în funcţie de hard-ul disponibil. Deşi programarea în limbaje de asamblare este mai uşoară decât în cod-maşină, există şi aici următoarele dezavantaje: - programele rezultate nu sunt potabile (un program scris într-un limbaj de asamblare la un calculator nu poate fi utilizat la un calculator de alt tip); - formatul instrucţiunilor este diferit de cel utilizat în limbajul natural, fapt ce îngreunează înţelegerea textului sursă; - programele rezultate au dimensiune mare şi productivitatea este scăzută.
17
Pentru a putea fi executate pe calculator, programele scrise în aceste limbaje trebuie mai întâi traduse în limbaj maşină, lucru ce este realizat prin intermediul unui program traducător specific limbajului utilizat, program numit asamblor. 3.3. Limbaje de nivel înalt Cercetările efectuate pentru elaborarea unor limbaje mai apropiate de limbajul natural au condus la crearea limbajelor de nivel înalt (high level programming languages) în care un program diferă foarte puţin de la un calculator la altul, fiind însă necesară prezenţa unui program numit compilator care sa traducă programul în instrucţiuni cod maşină. Aceste limbaje constituie generaţia a treia de limbaje de programare, primul limbaj de acest gen fiind limbajul Fortran (FORmula TRANslator) elaborat în 1954 sub conducerea lui John Backus. Limbajele din generaţia a treia se caracterizează prin [7]: - au un vocabular format din simboluri, cuvinte, fraze etc.; - operează asupra unor concepte de nivel logic (fişier, variabile, constante, operaţii de prelucrare etc.) spre deosebire de limbajul-maşină care operează cu elemente de nivel fizic (registru, locaşie de memorie, port de intrare etc.); - se bazează pe engleza structurată, apropiindu-se de limbajul utilizat in diferite domenii; - programele sunt mult mai uşor de scris şi citit, creşte productivitatea şi se reduc erorile de programare; - dispun, in general, de biblioteci speciale; - sunt, in general, limbaje procedurale (urmăresc, pas cu pas, procedura de rezolvare a problemei); - sunt orientate spre problemă iar programele rezultate sunt portabile (pot fi rulate pe orice tip de calculator, indiferent de tipul de microprocesor sau de sistemul de operare cu care acesta este dotat, fiind necesară doar prezenţa compilatorului aferent). Aceste limbaje au dominat mai bine de 30 de ani piaţa limbajelor de programare. Deşi există mii de astfel de limbaje, o clasificare simplificată ar putea fi următoarea [7]: 1) limbaje pentru calcule ştiinţifice: Fortran şi ALGOL (ALGOrithmical Language); 2) limbaje comerciale: COBOL (COmmon Busines Oriented Language) şi RPG (Report Program Generator); 3) limbaje pentru aplicaţii speciale: a) pentru simulare: Simula, GPSS, GPS; b) pentru aplicaţii militare în timp real: Ada; c) pentru programarea roboţilor şi a maşinilor unelte: FORTH; d) pentru rezolvarea problemelor de timp real: RTL/2, IRTB. Modula; e) pentru programare obiectuală: Smalltalk; 4) limbaje pentru destinaţii multiple: a) pentru instruire: Basic (Beginners All purpose Symbolic Instruction Code), Pascal; b) derivate din sisteme de operare: C, C++, B, BCPL; 18
c) pentru programare funcţională: Lisp (LISt Processing), APL (A Programming Language), ML (Mathematical Language). Limbajele din generaţia a 4-a au apărut odată cu dezvoltarea sistemelor de baze de date (SGBD-uri). Aceste limbaje se mai numesc şi generatoare de aplicaţii şi sunt preferate de către neinformaticieni. Principalele caracteristici ale acestor limbaje sunt: - o interfaţă prin instrucţiuni precum şi prin meniuri ş.a.; - caracterul neprocedural (utilzatorul trebuie să indice sistemului ce anume doreşte să facă şi nu cum să procedeze, sistemul rezolvând aceste probleme); - uşurinţa cu care se pot învăţa şi manevra; - independenţa datelor de progamele de apicaţii care le utilizează. Dintre limbajele din generaţa a 4-a fac parte limbajele din familia dBASE (dBASE, FoxBase, FoxPro), Paradox, Clipper, SQL (Structured Query Language), QBE (Query By Example), DB2 etc. Limbajele de generaţa a 5-a se utilizează pentru rezolvarea unor probleme de programare logică. Cel mai reprezentativ limbaj al acestei generaţii este PROLOG. O altă clasificare a limbajelor de programare se poate face [7] după modul şi nivelul de abstractizare, metodologiea programării, structura programului etc. : I) limbaje pentru programarea modulară şi structurată: Fortran, ALGOL, COBOL, Pascal, C; II) limbaje pentru programarea orientată pe obiecte: Smalltalk, Java, Python, Eiffel; II) limbaje pentru programarea concurentă şi distribuită: Concurent Pascal, CSP, Ada, Linda, Orca; IV) limbaje pentru programarea funcţională: Lisp, ML, Caml, Miranda, APL; V) limbaje pentru programarea logică: Prolog, Datalog. VI) limbaje pentru programarea la nivelul BD: limbajele incorporate in SGBD-urile respective, SQL, QBE; VII) limbaje pentru programarea vizuală: Visual Basic, Visual C++, Visual FoxPro Clasele rezultate nu sunt disjuncte, unele limbaje regăsindu-se în cadrul a mai multor clase. Astfel, Java este atât un limbaj pentru programare orientată pe obiecte, cât si pentru programarea concurentă şi distribuită dar şi vizuală. Activităţi necesare la elaborarea şi execuţia programelor: - scrierea programului sau codificarea (rezultă programul sursă sau codul sursă); - încărcarea în memorie şi salvarea pe disc; - compilarea (rezultă module obiect); - editarea de legături (rezultă program executabil); - depanarea; - execuţia. - întreţinerea Pentru redactarea unui program (tastarea instrucţiunilor) se utilizează un editor de texte. Având în vedere că de la operaţia de redactare a programului şi până la execuţia sa se parcurg o serie de activităţi menţionate mai sus, s-au creat aşanumitele medii de
19
programare care conţin instrumente (utilitare) pentru fiecare etapă (începând cu editoare de texte proprii şi terminănd cu comenzi pentru execuţia programului). Un salt important în activitatea de programare o constituie trecerea de la programarea procedurală (monolitică), în care un program este o secvenţă de instrucţiuni, la programarea visuală şi orientată obiect care permite generarea unui program şi a unor interfeţe utilizator prietenoase prin combinarea (manipularea) unor obiecte predefinite sau definite de utilizator şi ataşare de cod corespunzător. Astfel s-au estompat barierele dintre teoria şi practica programării, urmărindu-se simplificarea la maximum a programării şi, după posibilităţi, transferarea acesteia către calulator. Odată cu apariţia produselor CASE (Computer Added Software Engineering) se poate spune că programarea a trecut în faza de producţie. Probleme rezolvate 1. Un calculator poate executa un program: a) scris în orice limbaj de programare b) descris în limbaj maşină răspuns corect b) 2. Enumeraţi principalele dezavantaje ale programării în limbaj maşină. răspuns: - necesitatea descompunerii problemei de rezolvat în operaţii elementare pe care le poate executa calculatorul respectiv, cu specificarea codului numeric pentru instrucţiuni, date şi adrese de memorie; - lizibilitate scăzută şi o rată mare a erorilor; - dependenţa de un anumit tip de calculator; - dimensiune mare a programelor; - productivitate mică in activitatea de programare. 3. Un program scris într-un limbaj de asamblare poate fi executat: a) pe orice calculator b) numai pe tipul de calculator corespunzător limbajului de asamblare utilizat răspuns corect b) 4.
Un program scris într-un limbaj de asamblare poate fi executat pe calculator: a) fără a necesita alte transformări prealabile b) după încărcarea sa în memorie c) numai după traducerea sa în instrucţiuni cod maşină
răspuns corect c) 20
5. Enumeraţi principalele caracteristici ale limbajelor de programare din generaţia a treia răspuns: - au un vocabular format din simboluri, cuvinte, fraze etc.; - operează asupra unor concepte de nivel logic (fişier, variabile, constante, operaţii de prelucrare etc.) spre deosebire de limbajul-maşină care operează cu elemente de nivel fizic (registru, locaşie de memorie, port de intrare etc.); - se bazează pe engleza structurată, apropiindu-se de limbajul utilizat in diferite domenii; - programele sunt mult mai uşor de scris şi citit, creşte productivitatea şi se reduc erorile de programare; - dispun, in general, de biblioteci speciale; - sunt, in general, limbaje procedurale (urmăresc, pas cu pas, procedura de rezolvare a problemei); - sunt orientate spre problemă iar programele rezultate sunt portabile (pot fi rulate pe orice tip de calculator, indiferent de tipul de microprocesor sau de sistemul de operare cu care acesta este dotat, fiind necesară doar prezenţa compilatorului aferent). Probleme propuse 1.
Enumeraţi şi exemplificaţi principalele clase de limbaje de programare din generaţia a treia 2. Limbajele de programare din generaţia a patra au apărut: a) odată cu apariţia compilatoarelor b) ca urmare a dezvoltării sistemelor de baze de date c) pentru rezolvarea aplicaţiilor de programare logică 3.
Daţi exemple de limbaje din generaţia a patra
4.
Cel mai reprezentativ limbaj de programare logică este limbajul: a) SQL b) Simula c) PROLOG d) LISP e) Java
5.
Enumeraţi şi exemplificaţi principalele clase de limbaje de programare după metodologiea programării, structura programului:
6.
Care sunt principalele activităţi ce trebuie parcurse de la operaţia de redactare a unui program şi până la execuţia sa pe calculator: 21
7. Un mediu de programare este: a) un limbaj de programare evoluat b) o componentă a sistemului de operare c) un set de instrumente software care permite realizarea tuturor operaţiilor începând cu redactarea programului şi terminând cu execuţia sa pe calculator.
22
Capitolul 4. Consideraţii generale privind lexicul, sintaxa şi semantica unui limbaj de programare Rezumat- se prezintă alfabetul unui limbaj de programare, vocabularul limbajului, traducerea programelor (translatoare), analiya textului sursă a unui program (analiza lexicală, sintactică şi semantică). 4.1. Alfabetul şi vocabularul unui limbaj de programare Setul de caractere Orice limbaj de programare are la bază un anumit alfabet. În majoritatea cazurilor setul de caractere este format din: - literele alfabetului englez (de la A la Z, de obicei şi majusculele, şi literele mici, în total 52 de caractere); - cifrele arabe (de la 0 la 9, în total 10 caractere); - unele caractere speciale (. , ; = < > # $ % + - * / “ ‘ ( ) etc.) , a căror semnificaţie poate să difere de la un limbaj la altul. Pentru codificarea seturilor de caractere sunt utilizate următoarele standarde: - EBCDIC (Extended Binary Coded Decimal Interchenge Code), un cod pe 8 biţi, introdus de IBM; - ASCII (American Standard Code for Information Interchange), introdus de ANSI (American National Standard Institute), este un cod pe 7 biţi şi permite codificarea a 128 de caractere (95 de caractere tipăribile şi 33 de caractere netipăribile, numite caractere de control). Ulterior, setul ASCII a fost extins la o codificare pe 8 biţi, fiind disponibile astfel 256 de caractere. Primele 128 sunt din setul ASCII standard, iar următoarele 128 sunt coduri de caractere tipăribile pentru caracterele unor alfabete naţionale europene (francez, spaniol, român etc.), o parte din literele alfabetului grecesc, unele simboluri matematice , caractere speciale pentru desenat tabele etc. Ordonarea caracterelor alfabetului se face pe baza codurilor numerice corespunzătoare caracterelor respective. Pe baza caracterelor ce alcătuiesc alfabetul limbajului se alcătuiesc cuvintele care formează vocabularul limbajului şi cu ajutorul cărora se construiesc instrucţiunile limbajului. Există două categorii de cuvinte şi anume: 1. cuvinte cheie – acestea au un înţeles explicit într-un context precizat (de ex., in unele limbaje de programare cuvintele ce desemnează instrucţiuni pot fi folosite şi ca nume de variabile, neexistând restricţii; asemenea situaţii nu sunt însă indicate deoarece pot ascunde erori în logica programului şi îl fac mai greu de înţeles); 2. cuvinte rezervate – acestea nu pot fi folosite decât în scopul pentru care au fost definite (de ex., în limbajul Visual Basic). Avantajele utilizării acestei categorii de cuvinte sunt următoarele: - programul devine mai uşor de înţeles; - se măreşte viteza de compilare (analiza lexicală, sintactică şi semantică este mai simplă la căutarea în tabele de simboluri); 23
- erorile sunt mai uşor de depistat. Pe de altă parte, în cadrul unui limbaj de programare se vor utiliza cuvinte ale limbajului (rezervate) şi cuvinte definite de utilizator pentru a referi diverse elemente (variabile, fişiere, nume de proceduri, nume de funcţii, etc.). Sintaxa unui limbaj de programare Şi în cazul limbajelor de programare succesiunile de cuvinte construite după anumite reguli, formează propoziţii, numite instrucţiuni. Sintaxa unui limbaj de programare reprezintă ansamblul de reguli prin care se determină dacă o anumită instrucţiune este alcătuită corect sau nu. Sintaxa unui limbaj de programare poate fi descrisă în diverse moduri , unul dintre acestea fiind notaţia BNF (Backus-Naur Form). Notaţia BNF Notaţia BNF (Backus-Naur Form) a fost utilizată prima dată la descrierea sintaxei limbajului ALGOL (în cadrul raportului ALGOL60 apărut în 1963) şi este numită după doi dintre autorii acestui raport. În cadrul BNF sunt folosite metasimboluri, simboluri terminale si simboluri neterminale. Metasimboluri sunt simbolurile <, >, ½ şi ::= şi ele fac parte din mecanismul de descriere a limbajului. Simbolul ½ semnifică o alternativă, simbolul ::= inseamna „se defineşte astfel”. Simbolurile terminale sunt cuvinte care apar acolo unde se specifică în producţii (de ex., for, while, do, +, ; etc.). Simbolurile neterminale sunt încadrate în < şi > şi sunt definite prin producţii ale limbajului (de ex.,
, , etc.). Exemplu: în limbajul Visual Basic sintaxa unui identificator se descrie în BNF astfel: ::=½½ unde ::=a½b½...½z½A½B½...½Z ::=0½1½2½...½9 Conform acestei producţii, identificatorul are 3 definiţii alternative: un identificator este fie o , fie un urmat de o sau o (definiţie recursivă). Semnificaţia acestei definiţii este următoarea: un identificator poate să conţină o singură literă, sau o literă urmată de oricâte litere şi/sau cifre. Conform acestei definiţii, sunt corecte sintactic următorii identificatori: a, t1, sec12a1. Descrierea sintaxei instrucţiunii condiţionale IF…EndIf din limbajul Visual Basic în notaţie BNF este: ::= If < condiţie > Then < instrucţiuni 1 > Else < instrucţiuni 2 > EndIf
24
4.2. Traducerea programelor (translatoare) Translatorul este un program ce traduce un program sursă scris într-un anumit limbaj de programare întru-un program echivalent dintr-un alt limbaj, acest nou program numindu-se program destinaţie. Translatoarele se clasifică astfel: - compilatoare – pentru acestea programul destinaţie se numeşte program obiect sau cod obiect, fiind apropiat de codul maşinii; - asambloare – sunt compilatoarele limbajelor de asamblare; În aceste două cazuri traducerea de obicei este urmată de editarea de legături, înainte de execuţia propriu-zisă a programului. În această fază codul executabil se constituie prin legarea codului obiect rezultat din traducere cu alte module obiect (rezultate ale unor compilări anterioare sau cele existente în biblioteci). - interpretoare – realizează execuţia instrucţiune cu instrucţiune a programului sursă. - preprocesoare - traduc programe sursă din limbaje de nivel înalt în programe destinaţie tot în limbaje de nivel înalt; - cross-compilatoare sau cross-asambloare - generează pe un calculator „gazdă” un cod obiect pentru un alt calculator-obiect (care, de ex., are memorie mică şi nu poate implementa programul de traducere); - compilatoare incrementale - combinaţie compilator-interpretor, ce foloseşte secvenţe din programul sursă cu o anumită independenţă sintactică şi semantică pentru a le executa interpretativ. 4.3. Analiza textului sursă a unui program Analiza textului sursă constă din: analiza lexicală, analiza sintactică şi analiza semantică. Analiza lexicală Analiza lexicală realizează o primă parcurgere a programului sursă, considerat ca un şir de carctere şi grupează aceste caractere în subşiruri numite atomi lexicali: cuvinte cheie sau rezervate, operatori, constante, identificatori, separatori. Operaţiile pe care le realizează analizorul lexical sunt următoarele: - detectează în programul sursă subşiruri ce respectă regulile de formare a atomilor lexicali; - clasifică aceste subşiruri (identifică clasa la care aparţin aceste subşiruri); - traduce subşirurile în atomi lexicali; - memorează atomii în tabela de simboluri. Analiza sintactică În această fază în şirul atomilor lexicali se identifică structuri sintactice: expresii, liste, instrucţiuni, proceduri etc. şi se generează, în cazul în care şirul de intrare este corect sintactic, o descriere structurală a acestuia, semantic echivalentă - arborele sintactic (de
25
derivare) sau, în caz contrar, un mesaj de eroare. Arborele sintactic descrie relaţiile dintre structuri (separare, incluziune etc.). Analiza semantică. Analiza semantică foloseşte arborele sintactic, creat în faza de analiză sintactică, pentru a extrage informaţii privind apariţiile în programul sursă a obiectelor purtătoare de date (tipuri de date, variabile, proceduri, funcţii) şi a verifica consistenţa utilizării lor. Odată cu parcurgerea arborelui sintactic are loc şi generarea codului intermediar. Acesta reprezintă un şir de instrucţiuni simple, cu format fix, în care codurile operaţiilor sunt asemănătoare cu codurile maşină corespunzătoare, ordinea operaţiilor respectă ordinea execuţiei (conform apariţiei lor în programul sursă) iar operanzii sunt reprezentaţi sub forma variabilelor din programul sursă (nu sub formă de regiştri sau adrese de memorie). În practică, analiza semantică se desfăşoară în paralel cu cea sintactică, prin asocierea acţiunilor analizorului sintactic cu acţiuni referitoare la anumite structuri de date ce reprezintă atribute ale componentelor sintactice. Generarea codului obiect Generarea codului obiect presupune alocarea locaţiilor de memorie şi a regiştrilor unităţii centrale pentru variabilele programului şi înlocuirea codurilor de operaţii din codul intermediar cu cele maşină. Componente de bază (lexicală, sintactică, semantică) sunt asistate pe tot parcursul compilării de următoarele două module: Modulul de tratare a erorilor – o colecţie de proceduri care sunt activate ori de câte ori este detectată o eroare în timpul operaţiilor de analiză. După faza de analiza în care apar, erorile pot fi lexicale, sintactice sau de semantică. Procedurile de tratare a erorilor afişează mesaje de diagnostic relativ la eroare şi iau decizii privind modul de continuare a traducerii (se continuă , ignorând elementul ce conţine eroare, se încearcă corectarea erorii sau se intrerupe traducerea). Modulul de gestiune a tabelelor – o coleţie de proceduri care crează şi actualizează baza de date a compilatorului. Aceasta conţine informaţii proprii compilatorului (generate la implementare şi constituite din mecanismele de descriere a analizei lexicale, sintactice şi semantice) şi informaţii ce aparţin programului sursă ce se traduce (identificatorii, constantele, cuvintele cheie), memorate în tabela de simboluri. Gestionarea tabelei de simboluri se face în funcţie de modul de reprezentare al acesteia, caracterul general al tabelei, tipul limbajului din care se traduce programul sursă, convenţiile alese pentru reprezentarea atributelor în ea ş.a. De obicei, în faza de analiza lexicală, la întâlnirea unui nume nou, acesta este întrodus în tabela de simboluri, reţinându-se şi adresa intrării. Orice referire ulterioară la acest nume actualizează informaţia din tabelă corespunzătoare acestui nume, verificăndu-se şi consistenţa utilizării acestuia (în cadrul analizei semantice). La generarea codului, atributele numelui determină lungimea zonei de memorie alocată acestuia. Atributele numelui pot servi şi în faza de tratare a erorilor.
26
Probleme rezolvate 1. Alfabetul unui limbaj de programare este constituit din: a) literele alfabetului limbii române b) cifrele de la 0 la 9 c) literele alfabetului limbii engleze d) semne speciale e) cuvinte cheie răspuns corect b), c), d) 2.
Plecând de la alfabet se construiesc: a) instrucţiunile limbajului b) cuvintele limbajului c) programe d) vocabularul limbajului
răspuns corect d) 3. Vocabularul limbajului poate conţine: a) cuvinte rezervate b) cuvinte utilizator c) proceduri d) cuvinte cheie e) funcţii f) expresii răspuns corect a), b), d) 4. Analiza lexicală, sintactică şi semantică a unui program sursă se realizează în faza: a) de execuţie b) de compilare c) de editare de legături d) de implementare e) de scriere a programului. răspuns corect b)
27
Probleme propuse 1.
O instrucţiune a limbajului este: a) orice succesiune de cuvinte din vocabular b) o succesiune de cuvinte din vocabular, construită după anumite reguli sintactice c) orice propoziţie din limba engleză 2. Notaţia BNF este: a) o metodă de reprezentare a unui program b) o modalitate de descriere a sintaxei unui limbaj de programare c) o metodă de descriere a unui algoritm 3. Enumeraţi principalele tipuri de translatoare şi funcţiile acestora.
4.
Un program scris într-un limbaj de programare se numeşte: a) program obiect b) program sursă c) program destinaţie d) program executabil
28
Capitolul 5. Limbajul Visual Basic Rezumat- se prezintă limbajul de programare Visual Basic sub Excel, şi un exemplu de realizare a unei aplicaţii Windows pentru calculul salariilor personalului angajat al unei firme. 5.1. Programarea aplicaţiilor Windows Pentru realizarea unei aplicaţii pot fi avute în vedere două tehnologii de programare şi anume: - programare procedurală - programare orientată spre obiecte şi dirijată de evenimente. În programarea procedurală, o aplicaţie este constituită din unul sau mai multe programe care se vor executa într-o anumită ordine, fiecare program fiind constituit dintr-o secvenţă de instrucţuni scrise într-un limbaj de programare. Acesta era modul clasic de realizare a aplicaţiilor şi sistemelor informatice şi are o serie de dezavantaje printre care: productivitate scăzută în realizarea programelor, efort mare pentru realizarea programelor şi mai ales a interfeţelor etc. Apariţia tehnologiei orientate obiect, a mediilor visuale de programare şi a sistemului de operare Windows a condus la apariţia şi dezvoltarea unei noi tehnologii de programare a aplicaţiilor windows şi anume programarea orientată pe obiecte şi dirijată de evenimente, tehnologie ce va fi prezentată în cele ce urmează în cadrul limbajului Visual Basic. O aplicaţie Windows afişează unul sau mai multe ecrane care conţin obiecte cu care va interacţiona utilizatorul pentru a controla evoluţia programului. Într-un mediu de programare vizual, obiectele principale sunt formele şi controalele desenate în forme (formă = o fereastră) Aceste obiecte pot fi create prin selecţie şi depunere folosind barele de instrumente ale mediului respectiv. Spre exemplu, bara cu instrumente Visual Basic permite crearea unei varietăţi de obiecte printre care: forme, butoane, casete cu listă, casete derulante combinate, casete de validare, butoane radio (butoane de opţiune), etc. Fiecare din aceste obiecte are un comportament predefinit. Spre exemplu când se execută click pe un buton acesta trece în poziţia apăsat şi apoi revine în poziţia normală. Pentru a schimba comportamentul obiectului acestuia trebuie să-i ataşaţi cod de program (instrucţiuni) corespunzător, cod ce se va executa atunci când are loc un anumit eveniment (spre exemplu în cazul butonului evenimentul este click). Evenimentele se produc ca urmare a unei acţiuni a utilizatorului (ex. evenimentul click corespunde apăsării butonului stâng al mouse-ului pe obiectul respectiv), sau în urma execuţiei codului programului, sau pot fi declanşate de către sistem. Majoritatea obiectelor vor răspunde unui anumit număr de evenimente generate de către utilizator printre care click-uri, dublu click-uri, apăsări de taste sau trageri şi eliberări ale obiectului. Limbajul Visual Basic pune la dispoziţia utilizatorului un mediu de dezvoltare care permite crearea de programe orientate spre obiecte şi conduse de evenimente. Pentru lucrul cu obiecte conduse de evenimente se parcurg următoarele etape: 29
se creează o nouă formă căreia i se dă un nume; se desenează şi se denumesc obiectele ce urmează a fi afişate în forma respectivă; se ataşează fiecărui obiect codul ce va fi executat ca răspuns la evenimente generate de utilizator sau de sistem. Va rezulta o interfaţă grafică cu care interacţionează utilizatorul pentru a controla evoluţia programului. Rezumând putem spune că în programarea orientată spre obiecte şi dirijată de evenimente, obiectele au un comportament predefinit care poate fi modificat de utilizator prin ataşare de cod corespunzător şi aceste obiecte răspund la evenimente declanşate fie ca urmare a acţiunii utilizatorului asupra obiectelor, fie ca urmare a execuţiei codului ataşat, fie declanşate de sistem. -
5.2. Proprietăţi şi metode Un obiect este definit de un set de proprietăţi cum ar fi: dimensiune, culoare, poziţie pe ecran, comportament (ex. dacă un buton radio este activ sau nu la un moment dat etc.). O metodă este o procedură (succesiune de instrucţiuni) asociată unei anumite acţiuni a unui obiect. Spre exemplu în Visual Basic există o metodă Move asociată majorităţii obiectelor (permite mutarea obiectelor). Deci proprietăţile descriu obiectele iar metodele definesc acţiunile obiectelor, iar pe de altă parte proprietăţile reprezintă date iar metodele reprezintă cod (instrucţiuni). Astfel în gramatica programării orientate spre obiecte : - obiectele sunt substantive; - proprietăţile sunt adjective; - metodele sunt verbe. Utilizarea notaţiei cu punct pentru referirea proprietăţilor şi metodelor Referirea unei proprietăţi se face astfel: Obiect . Proprietate = Valoare Exemplu - fie forma frmForma1 şi variabila dColor în care memorăm culoarea de fond a formei dColor = frmForma1.BackColor (citeşte culoarea curentă şi o depune în dColor) frmForma1.BackColor = QBColor (Blue) - stabileşte noua culoare de fond a formei la valoarea Blue. Referirea metodelor se face asemănător cu referirea proprietăţilor, însă în plus metodele pot necesita precizarea unor informaţii suplimentare. Exemplu - pentru mutarea obiectului Buton1 în colţul din stânga sus al formei curente se apelează metoda Move şi se precizează coordonatele colţului din stânga sus: Buton1.Move 0,0 Stabilire proprietăţi şi executare metode Proprietăţile unui obiect pot fi setate în faza de proiectare (atunci când se desenează sau se modifică formele) utilizând fişa Properties a formei sau obiectului din formă (fişa
30
este automat vizualizată la selecţia obiectului respectiv: forma, buton, etc.). De asemenea fişa Properties poate fi vizualizată prin click dreapta şi selecţie Properties. Proprietăţile pot fi modificate şi prin program în momentul execuţiei formei, dacă codul de program asociat conţine instrucţiuni care referă şi setează proprietăţi (ca în exemplul de mai sus în care schimbăm culoarea fondului formei). Spre deosebire de proprietăţi, metodele pot fi executate numai în momentul execuţiei programului (eventual în momentul depanării programului utilizând facilitatea Debugger a programului Visual Basic). Denumirea obiectelor Orice obiect are proprietăţile: Name - numele utilizat în scrierea codului Capture - numele dat obiectului pentru a putea fi identificat de utilizator. Visal Basic dă nume implicite obiectelor. Este indicat ca utilizatorul să dea nume obiectelor (Name) utilizând următoarea convenţie: - un prefix format din 3 litere mici (ex. frm pentru formă, cmd pentru buton de comandă, etc.) - un şir de caractere care identifică obiectul (ex. Forma1, Ecran1, Buton1, etc.). În tabelul următor sunt prezentate convenţiile de denumire a obiectelor din Visual Basic: Obiect
Prefix
Exemplu
Formă Buton de comandă Casetă de text Bare de derulare - orizontală - verticală Meniu Casetă de validare Casetă cu lista Cadru Imagine Buton de opţiune (radio)
frm cmd, btn txt
frmForma1 cmdButon, btnOK txtCaseta1
hsb vsb mnu chk lst fra img opt
mnuMeniuPrinc
optBO1
31
5.3. Utilizare Visual Basic din Excel
Lansare editor Visual Basic: Tools →Macro →Visual Basic Editor
32
Creare formă: Insert→UserForm
Ştergere formă: File→ Remove UserForm (pentru forma selectată = ultima activată) →No (fără export = fără salvare)
33
După creare formă se pot desena obiecte în formă utilizând bara de instrumente Toolbox Controls prin selectare obiect, antrenare pe suprafaţa formei şi depunere obiect ca în exemplul de mai jos:
În partea stângă a ecranului este afişată lista proprietăţilor obiectului selectat (care pot fi eventual modificate - setate). Cu click dreapta pe obiect se pot vizualiza: - proprietăţile obiectului - codul asociat şi eventual se pot efectua şi alte operaţii (Cut, Copy, Paste, Delete). Vizualizare forme View →Project Explorer → din lista Project ce apare se alege forma dorită (care poate fi editată cu click dreapta, sau executată din Run Sub / UserForm). sau selecţie obiect din lista Project şi apoi View → Object (pentru afişare obiect în modul Design)
34
Code (pentru afişare cod pentru obiectul selectat)
35
Execuţie formă: Run → Run Sub / UserForm (pentru formă curentă)
Pentru revenire în ecranul anterior (editorul Visual Basic) se închide forma (se apasă butonul Close al formei)
36
5.4. Variabile
O variabilă este o zonă temporară de memorie căreia i se dă un nume, şi care poate memora (stoca) un anumit tip de dată care poate fi modificată pe parcursul execuţiei programului. În Visual Basic numele unei variabile poate avea max. 256 caractere, trebuie să înceapă cu un caracter alfanumeric (litere, cifre) şi nu poate fi un cuvânt rezervat al limbajului Visual Basic (cum ar fi Sub, Function, etc.). Tipuri de variabile în Visual Basic Tip
Sufix
Byte Boolean
-
Dimensiune (octeţi) 1 2
Integer – întreg Long integer - întreg lung
% &
2 4
Simplă precizie Dublă precizie Currency – valută Date - dată calendaristică Object – obiect String – şir Variant – nedefinit User-Defined (definit de utilizator)
! # @ $ -
4 8 8 8 4 1/caracter după caz după caz
Domeniu de valori 0-255 Adevărat, Fals (True, False) -32768, + 32768 -2.147.483.648, 2.147.483.647 -3.40E38 ; 3.40E38 -1.80E308 , 1.80E308 -9.22E14 , 9.22E14 ian 1, 100 ; dec 31 ,9999 Adresa unui obiect 65500 octeţi în funcţie de tip în funcţie de tipul elementelor
Declaraţii implicite şi explicite de variabile Declararea implicită se face utilizând sufixul (ca în tabelul de mai sus). Exemplu: Vârsta% = 42 (variabila vârsta este de tip întreg) Dacă ultimul caracter nu este unul din caracterele de declarare a tipului: %, &, !, # , @, $ atunci tipul prestablit este variant. Declararea explicită a unei variabile se face utilizând instrucţiunea Dim la începutul unei proceduri. Exemplu: Dim Varsta As Integer Dim X As Double Dim sir1, sir2 As String (sir1 este de tip variant, sir2 este de tip string) Dim sir As String ∗ 10 (de tip şir ce poate conţine max. 10 caractere) Domeniul unei variabile
37
Domeniul unei variabile este zona programului în care variabila este vizibilă. Întrucât o variabilă poate fi declarată la 4 nivele diferite există corespunzător 4 nivele diferite de domenii de vizibilitate şi anume: 1. nivel procedură 2. variabile statice în interiorul procedurilor 3. nivel formă 4. nivel modul standard Nivelul procedură este primul nivel la care poate fi declarată o variabilă fie implicit fie cu instrucţiunea Dim. Există două tipuri de procedură în Visual Basic şi anume: - proceduri Sub - proceduri Function. Variabilele declarate în proceduri vor fi variabile locale ale procedurilor respective, fiind valabile (accesibile) numai în procedurile în care au fost declarate. Deci aceste variabile au cea mai redusă vizibilitate şi cel mai restrâns domeniu. Când execuţia unei proceduri se încheie, toate variabilele locale ale acesteia sunt eliminate din memorie. # Deci variabilele locale ale unei proceduri sunt reiniţializate la fiecare apel al procedurii. 1.
Variabile statice - în interiorul procedurilor O variabilă locală poate fi făcută permanentă dacă în locul instrucţiunii Dim se foloseşte instrucţiunea Static. Astfel o variabilă statică îşi conservă valoarea între apelurile succesive ale procedurii în care a fost declarată (deci nu va fi reiniţializată la fiecare apel al procedurii), însă este vizibilă numai în cadrul procedurii în care a fost declarată. 2.
3. Variabile la nivel formă O variabilă declarată la nivelul unei forme, va fi accesibilă la nivelul tuturor procedurilor acelei forme. Variabile la nivelul modul standard Modulele de cod sunt module utilizate pentru a păstra procedurile şi funcţiile generale neinfluenţate de evenimente şi variabilele şi constantele globale. Aceste module se creează prin selectarea opţiunii Module din meniul Insert al programului Visual Basic, sau prin click pe butonul module din bara cu instrumente. Declararea unei variabile la nivelul unui astfel de modul se face prin plasarea acesteia în zona de declaraţii a obiectului General, zonă accesibilă prin intermediul ferestrei de cod. Cel mai înalt domeniu de vizibilitate este nivelul global. Orice variabilă declarată la acest nivel este vizibilă din orice procedură a aplicaţiei (proiectului). Declararea unei variabile globale se face utilizând cuvântul cheie Global în secţiunea General / Declaration a modulului de cod. Exemplu: Global NumePrenume As String Constante 4.
38
O constantă poate fi privită ca o variabilă a cărei valoare nu se modifică niciodată rămânând aceeaşi pe parcursul întregii vieţi a programului. Utilizarea constantelor duce la creşterea calităţii programelor. Ca şi în cazul unei variabile, domeniul unei constante este determinat de locul unde este declarată. Constantele se declară cu cuvântul cheie Const. Este indicat ca numele constantelor să fie scrise cu litere mari pentru a fi uşor reperabile. Exemplu de utilizare InputBox( ), MsgBox Const IB_TITLU = "Titlu InputBox" Dim sNume As String ‘variabilă locală Dim sPrompt as string Static ixPos As Integer, iyPos As Integer ‘valoare păstrată între apeluri SPrompt = "Introduceţi numele dumneavoastră:" ixPos = Iif(ixPos > 0, 0, 1440) ‘ schimbă poziţia ferestrei iyPos = Iif (iyPos >0, 0, 1440) sNume = InputBox$ (sPrompt, IB-TITLU, ixPos, iyPos) If sNume = " " Then MsgBox "Nu s-a introdus nimic!" Tipuri de date definite de utilizator În afară de tipurile de date predefinite în cadrul limbajului Visual Basic, utilizatorul poate să-şi definească propriile sale tipuri de date, care pot conţine unul sau mai multe tipuri de date predefinite. Tipurile de date definit de utilizator pot fi declarate numai în secţiunea General / Declaration a modulului de cod cu ajutorul cuvintelor cheie Type şi End Type (deci tipurile definite de utilizator sunt vizibile din orice punct al aplicaţiei, proiectului respectiv). Exemplu: Type t_pers Nr As Integer Nume As String ∗ 30 DataNasterii As Date End Type După definirea unu astfel de tip de dată acesta poate fi utilizat pentru declararea unei variabile de acest tip. Pentru variabilă se poate utiliza Dim, Static, Global pentru a defini domeniul de vizibilitate al acestei variabile. Exemplu: Dim Persoane As t_pers Persoane.Nr = 15 Pesoane.Nume = "Ionescu Ion" Persoane.DataNasteri = #december 20 ,1983 # Astfel de tipuri de variabile sunt utilizate în programele de baze de date. Prefixele variabilelor De obicei fiecare programator îşi defineşte variabilele utilizând un prefix scris cu litere mici pentru a identifica tipul variabilei după cum urmează: 39
i - Integer s - String l - Long -------Există o listă standard de prefixe de variabile numită notaţie ungară (Hungarian Notation) - inventată de un programator de naţionalitate ungară de la firma Microsoft pentru limbajul C. 5.5. Operaţii de intrare /ieşire realizate cu funcţiile InputBox ( ) şi MsgBox ( ) Limbajul Visual Basic dispune de funcţiile InputBox ( ) şi MsgBox ( ) pentru realizarea de operaţii simple de intrare/ieşire prin utilizarea unor casete de dialog predefinite. În cadrul unui program utilizatorul trebuie să poată introduce date şi să poată afişa sau extrage rezultate. Funcţia InputBox ( ) - afişează o casetă de dialog şi aşteaptă ca utilizatorul să introducă text, apoi returnează conţinutul casetei de text. Valoarea returnată este fie de tip variant fie de tip String în funcţie de varianta utilizată: Valret = InputBox (prompt, title, default, xpos, ypos, helpfile, context) - întoarce Variant Valret$ = InputBox$ (prompt, title, default. xpos, ypos, helpfile, context) - întoarce String - Argumentul prompt este singurul argument obligatoriu, care va fi un mesaj (de tip String) care invită utilizatorul să introducă text în caseta de text afişată. Pentru a introduce text pe mai multe linii se va introduce CR. LF, (chr(13), chr(10)) sau constanta predefinită vbcrlf, între fiecare două rânduri succesive). - Title este un şir de caractere ca va fi afişat în bara de titlu a casetei de dialog. - Default - se poate completa pentru acest argument un şir de caractere care să fie considerat răspunsul predefinit (va apare afişat în caseta de text), iar dacă nu se completează, caseta de text (în care utilizatorul va introduce textul) va fi afişată goală. - xpos, ypos - sunt expresii numerice care specifică distanţa pe orizontală, verticală a colţului din stânga sus al casetei de dialog faţă de colţul din stânga al ecranului (formei). Dacă sunt omise, caseta de dialog va fi centrată pe orizontală la o treime din înălţimea ecranului. Dacă se omite title sau default sau ambele şi vrem să precizăm xpos, ypos atunci în locul argumentelor omise se va folosi câte o virgulă pentru fiecare argument omis. - Pentru ambele funcţii InputBox( ) şi MsgBox( ), argumentele helpfile (şir) şi context (nr. întreg) sunt utilizate pentru a pune la dispoziţie asistenţă soft dependentă de context, caz în care utilizatorul poate apăsa tasta F1 pentru a vedea articolul Help creat pentru respectiva casetă de dialog. Dacă se selectează butonul OK sau se apasă Enter, funcţia InputBox( ) returnează conţinutul casetei de text. Dacă nu se introduce text sau se selectează butonul Cancel, funcţia returnează un şir de lungime 0 (" "). Variabila Valret va memora conţinutul casetei de text (textul introdus).
40
Funcţia MsgBox ( ), procedura MsgBox Funcţia MsgBox( ) şi procedura MsgBox afişează un mesaj într-o casetă de dialog şi aşteaptă ca utilizatorul să selecteze un buton. Funcţia MsgBox ( ) returnează o valoare întreagă care indică numărul butonului selectat. Procedura MsgBox nu returnează nici o valoare ( se utilizează atunci când nu interesează cum este închisă caseta de dialog corespunzătoare). Sintaxa funcţiei MsgBox ( ) este: Valret % = MsgBox(msg, type, title, helpfile, context) Sintaxa procedurii MsgBox este: MsgBox msg, type, title, helpfile, context -msg = expresie şir afişată ca mesaj în caseta de dialog -type = expresie numerică ce precizează numărul şi tipul butoanelor şi a altor elemente ce vor fi afişate în caseta de dialog corespunzător tabelului de mai jos. În tabelul de mai jos sunt date grupele de valori care descriu: 1. numărul şi tipul butoanelor casetei de dialog 2. tipul pictogramei 3. butonul prestabilit 4. modalitatea casetei de dialog. Valoare 0 1 2 3 4 5
Semnificaţie Afişează numai butonul OK Afişează butoanele OK şi Cancel Afişează butoanele Abort,Retry,Ignore Afişează butoanele Yes, No, Cancel Afişează butoanele Yes, No Afişează butoanele Retry, Cancel
Constanta simbolică recomandată vbOKOnly vbOKCancel vbAbortRetryIgnore vbYesNoCancel vbYesNo vbRetryCancel
16 32 48 64
Afişează pictograma Critical Afişează un semn de întrebare Afişează un semn de exclamare Afişează pictograma Information
vbCritical vbQuestion vbExclamation vbInformation
0 256 512
Primul buton este prestabilit Al doilea buton este prestabilit Al treilea buton este prestabilit
vbDefaultButton1 vbDefaultButton2 vbDefaultButton3
0 4096
Casetă modală aplicaţiei Casetă modală sistemului
vbApplicationModal vbSystemModal
Pentru a obţine valoarea argumentului type se va însuma câte un număr din fiecare grup. Dacă argumentul type este omis se consideră implicit valoarea 0. Modalitatea implicită a unei casete de dialog este ApplicationModal.
41
În modalitatea aplicaţie utilizatorul trebuie să răspundă casetei de dialog înainte de a putea să lucreze în aplicaţia curentă. În modalitatea System toate aplicaţiile sunt suspendate până când utilizatorul răspunde casetei de dialog. Atât pentru funcţia MsgBox( ) cât şi pentru procedura MsgBox argumentul msg este obligatoriu, celelalte fiind facultative. Valoarea returnată de funcţia MsgBox( ) indică butonul care a fost selectat, conform tabelului de mai jos: Valoare 1 2 3 4 5 6 7
Semnificaţie Butonul OK selectat Butonul Cancel selectat Butonul Abort selectat Butonul Retry selectat Butonul Ignore selectat Butonul Yes selectat Butonul No selectat
Constanta simbolică recomandată vbOK vbCancel vbAbort vbRetry vbIgnore vbYes vbNo
Este indicat a se utiliza constante simbolice în locul numerelor deoarece în acest fel creşte claritatea programului (semnificaţia constantei vbAbort este evidentă, pe când nr. 3 nu spune nimic). 5.6. Structuri de ramificare şi ciclare (luare decizii) Pentru luarea deciziilor în cadrul unui program Visual Basic se pot utiliza două categorii de instrucţiuni cu ajutorul cărora se dirijează execuţia instrucţiunilor programului în funcţie de îndeplinirea anumitor condiţii. Cele două categorii de instrucţiuni sunt: - instrucţiuni de ramificare – permit execuţia selectivă a anumitor secvenţe de instrucţiuni funcţie de îndeplinirea unor condiţii - instrucţiuni de ciclare – permit execuţia repetată a unor secvenţe de instrucţiuni. 5.6.1.Structuri de ramificare 1) Structura If….EndIf - are sintaxa If < condiţie > then < instrucţiuni 1 > Else < instrucţiuni 2 > EndIf Dacă este adevărată se execută secvenţa de instrucţiuni şi se continuă programul cu instrucţiunile care urmează după EndIf. Dacă este falsă se execută secvenţa de instrucţiuni şi se continuă programul cu instrucţiunile care urmează după EndIf.
42
Exemplu: If
Culoare < 15 Then Culoare = Culoare + 1
Else Culoare = 1 EndIf Se pot construi structuri If imbricate (incluse), însă pentru aceasta se poate utiliza simplu structura If……ElseIf…..EndIf, sau în cazul mai multor acţiuni se poate utiliza structura Select Case. Exemplu: If iValRet = vbYes Then sMsg = "A-ţi selectat Yes" Elseif iValRet = vbNo Then sMsg = "A-ţi selectat No" Else If iValRet = vbCancel then SMsg = "A-ţi selectat Cancel" EndIf Structura If……ElseIf….EndIf poate fi condensată într-o singură linie de cod utilizând funcţia IIF ( ) ca în exemplul de mai jos: Culoare = IIF (Culoare <15, Culoare, 1) ‘(testează să nu se depăşească codul 14 pentru culoare) 2) Structura Select……EndSelect - pentru realizarea unei acţiuni din mai multe posibile. Exemplu: fie iVarsta o variabilă numerică în care este memorată vârsta. Select Case iVarsta Case 5 sGrupa = "de cinci ani" = 5 ani Case 13 To 19 sGrupa = "Adolescent" Case 20 To 35, 50, 60 to 65 sGrupa = "adult" Case Is > 65 sGrupa = "vârstnic" Case Else sGrupa ="ceilalţi" EndSselect În funcţie de condiţia (prima îndeplinită ) se execută secvenţa de instrucţiuni corespunzătoare, apoi se continuă cu instrucţiunile care urmează după EndSelect. Dacă nici una din condiţiile anterioare nu este îndeplinită se execută instrucţiunile care urmează după CaseElse.
43
5.6.2. Structuri de ciclare 1) While…..Wend are sintaxa: While Wend Se execută secvenţa de instrucţiuni atâta timp cât condiţia este îndeplinită (adevărată). 2) Do….Loop are sintaxa: Do Until Loop sau Do ………….. If Then Exit Do Else Loop Until Structura Do…Loop repetă un bloc de instrucţiuni atâta timp cât o anumită condiţie este adevărată sau până în momentul în care o anumită condiţie devine adevărată. Instrucţiunea Exit Do poate fi folosită numai într-o structură Do….Loop ca o condiţie de a părăsi ciclul. 3) For…Next - repetă o secvenţă de instrucţiuni de un număr precizat de ori după următoarea sintaxă: For icontor = To [Step ] Next Execuţia ciclului For…Next se poate termina forţat cu instrucţiunea Exit For. Exemplu: (calculează suma numerelor pare până la 100). For iNr = 0 TO 100 step 2 isuma = isuma + iNr Next 5.7. Module şi proceduri În Visual Basic 4.0, există trei tipuri de module: -
module ale formei module de cod module clasă 44
Fiecare tip de modul conţine proceduri care pot fi partajate pe diverse nivele ale domeniului de vizibilitate în cadrul aplicaţiei. Toate exemplele date până în prezent cu excepţia variabilelor globale vor fi stocate în module asociate unor forme. Exemplu - dacă se scrie cod asociat evenimentului click al unui buton va rezulta o procedură de eveniment (spre deosebire de o procedură generală) care va fi parte a formei în care se află butonul. Cu excepţia cazului când se elimină cuvântul cheie Private din antetul procedurii de eveniment a formei, acest cod nu va fi vizibil în afara formei. O clasă este un şablon în baza căruia pot fi create obiecte. Clasa defineşte proprietăţile obiectelor ce aparţin clasei şi metodele utilizate pentru controlul comportamentului obiectelor. Modulele clasă conţin o definiţie formală a unei clase care va fi instanţiată ca obiect OLE automatic. Un modul de cod conţine cod public, declaraţii, proceduri subrutină şi funcţii care pot fi partajate între toate modulele unui proiect. Modulul de cod este numit şi modul standard pentru a putea fi diferenţiat de modulele formei şi modulele clasă. Proceduri generale şi proceduri eveniment O procedură generală comunică aplicaţiei cum să efectueze o anumită acţiune. Pentru a efectua acţiunea, procedura trebuie apelată explicit în cadrul aplicaţiei. O procedură generală poate fi plasată în oricare din cele 3 tipuri de module. O procedură eveniment rămâne inactivă până când este apelată pentru a răspunde unor evenimente provocate de utilizator (ex. click cu mouse-ul) sau declanşate de sistem (ex. evenimente de ceas, evenimente de încărcare în memorie). 5.7.1. Proceduri subrutine O procedură subrutină (sau simplu procedură) este o secvenţă de instrucţiuni care are un nume şi ale cărei instrucţiuni sunt executate ca un tot. O procedură subrutină efectuează o anumită acţiune însă nu returnează nici o valoare. O procedură subrutină începe cu instrucţiunea Sub şi se termină cu instrucţiunea End Sub (exemplu procedura asociată evenimentului click al unui buton). Limbajul Visual Basic are o serie de proceduri încorporate ca de exemplu: Procedura MsgBox Print FileCopy Name Kill Beep Date
Descriere Afişează un mesaj într-o casetă Tipăreşte Copiază un fişier Redenumeşte un fişier Şterge un fişier Emite un sunet Stabileşte data sistemului
Exemplu de utilizare MsgBox "mesaj",…. Print iProcent & "%" FileCopy "Fis1.doc", "Fis2.doc" Name "Fisier1" As "Fisier2" Kill "Fis1.doc" Beep Date #December 18, 2002#
Utilizatorul îşi poate defini propriile proceduri pentru a efectua diverse acţiuni. Exemplu: 45
Sub StergeFisiere( ) Kill " *.Tmp" Kill " *. Dat" Beep MsgBox "S-au şters fişierele *.Tmp, *.Dat" End Sub Pentru apelarea procedurii ŞtergeFisiere din orice punct al aplicaţiei se va specifica numele procedurii ca instrucţiune în cadrul programului. (deşi parantezele apar în definiţia procedurii, la apelul procedurii se va specifica doar numele fără paranteze !). Procedura de mai sus nu necesită argumente, însă dacă o procedură urmează să primească argumente acestea se vor specifica ca în exemplul: Sub Produs(iNr1 As Integer, iNr2 As Integer) iVarGlobal = iNr1*iNr2 End Sub Apelul procedurii este ilustrat în exemplul de mai jos: Dim iV1 As Integer, iV2 As Integer iV1 = 560 iV2 = 829 Produs iV1, iV2 ………………. 5.7.2. Proceduri funcţii O procedură funcţie (sau simplu o funcţie) este o secvenţă de instrucţiuni care efectuează o anumită operaţie într-un program şi returnează o valoare. O funcţie începe cu instrucţiunea Function şi se termină cu instrucţiunea End Function. În Visual Basic există o serie de funcţii predefinite printre care: Funcţia Len( ) Mid( ) Chr( ) Asc( ) UCase( ) LCase( ) InStr( )
Descriere Returnează lungime şir Returnează un subşir din şir Returnează caracterul corespunzător codului Returnează codul corespunzător caracterului Converteşte în litere mari Converteşte în litere mici Returnează poziţia unui subşir în şir
Exemplu de utilizare iLung=Len("Limbaje de programare") sSubsir=Mid("ABCDE", 1,2)
Valoare returnată iLung = 21 sSubsir = "AB"
sCar = Chr(65)
sCar = "A"
iCod = Asc ("A")
iCod = 65
sMari = Ucase("Ionescu") sMici = Lcase("LIMBAJE")
sMari = "IONESCU" sMici = "limbaje"
iPozitie = Instr("ABCDE", "BCD")
iPozitie = 2
46
Pe lângă funcţiile predefinite fiecare utilizator îşi poate crea propriile funcţii Exemplu - definirea unei funcţii utilizator pentru criptarea unui şir de caractere Function Criptare(sSirTastat As String ) As String Dim iLen As Integer Dim sSirCriptat As String, sCar As String, sCript As String iLen = Len(sSirTastat) ′ depune în iLen lungimea şirului tastat For x = 1 To iLen ′ pentru fiecare caracter din şirul tastat sCar = Mid$(sSirtastat, x, 1) ′ extrage caracterul sCript = Chr$(Asc(sCar) +1) ′ criptează caracterul prin incrementare cu 1 sSirCriptat = sSirCriptat&sCript ′ adaugă caracterul criptat şirului criptat Next Criptare = sSirCriptat End Function Apelul funcţiei Criptare: Private Sub frmApel Dim sRezultat As String sSirTastat$ = InputBox$("Tastează şirul de criptat") Srezultat = Criptare(SirTastat$) MsgBox Srezultat End Sub Dacă vrem să descriptăm şirul criptat vom scrie o funcţie care este aproape identică cu cea de criptare şi anume: Function Decriptare(sSirIntrare As string) As string ′ nume diferit Dim iLen As Integer Dim sSirIesire As string, sCarIntrare As string, sCarIesire as string iLen = Len(sSirIntrare) For x = 1 To iLen sCarIntrare = Mid$(sSirIntrare, x, 1) sCarIesire = Chr$(Asc(ScarIntrare)-1) ′ minus în loc de plus sSirIesire = sSirIesire & sCarIesire Next Decriptare = sSirIesire ′ Decriptare în loc de criptare End Function Se constată că cele două funcţii pot fi scrise ca o singură funcţie de două argumente şi anume: Function CriptDecript (sSirIntrare As String, iOperatie As Integer) As String Dim iLen As Integer Dim sSirIesire As string, sCarIntrare As String, sCarIesire As String iLen = Len(sSirIntrare) For x = 1 To iLen sCarIntrare = Mid$(sSirIntrare, x, 1) sCarIesire = Chr$(Asc(sCarIntrare) + iOperatie)
47
sSirIesire = sSirIesire & sCarIesire Next CriptDecript = sSirIesire End Function iar la apelarea funcţiei iOperatie va fi: +1 pentru criptare -1 pentru decriptare Exemplu de apel: Dim V1 As String, V2 As String V1 = InputBox$("Introduceţi şirul de criptat") V2 = CriptDecript(V1, 1) MsgBox V2 Pentru crearea procedurilor şi funcţiilor se deschide fereastra de cod a modulului de cod standard. Lista Object conţine cuvântul General iar lista Proc conţine cuvântul Declarations. În secţiunea General Declaration a modului se vor declara variabilele şi constantele la nivel de modul (globale) şi apoi se definesc (introduc) procedurile şi funcţiile modulului (codul sursă prezentat mai sus). Observaţii Fiecare din funcţiile şi procedurile aplicaţiei pot fi ataşate unor obiecte grafice (butoane), deci în acest caz textul sursă corespunzător se va ataşa butoanelor respective. Indiferent dacă o funcţie are sau nu argumente, atât la definire cât şi la apelare, parantezele sunt obligatorii !! 5.8. Obiecte în Visual Basic
Bare cu instrumente - Butoane de comandă - sunt utilizate pentru a începe, a întrerupe sau a încheia un anumit proces. Când se execută click cu mouse-ul arată ca şi cum ar fi apăsat, de unde şi denumirea sa în engleză Push button. Pentru a afişa text pe buton trebuie definită proprietatea Caption. Prezenţa unui caracter & în textul proprietăţii Caption face ca ceea ce urmează după & să fie tasta de acces în combinaţie cu tasta Alt. Selecţia unui buton de comandă se face prin click cu mouse-ul sau cu tasta Tab pentru a ajunge pe buton şi apoi se apasă tasta Enter. Dacă proprietatea Default a unui buton are valoarea True, atunci acest buton poate fi selectat în orice moment prin apăsarea tastei Enter indiferent ce control este curent în acel moment. Dacă proprietatea Cancel a unui buton este stabilită pe valoarea True atunci acel buton poate fi selectat prin tasta Esc.
48
Proprietăţi uzuale ale unui buton de comandă Proprietate Descriere Appearance Selectează aspectul 3D sau plat Cancel Permite selectarea cu ESC Caption Şirul de caractere afişate pe buton Default Permite selectarea cu tasta Enter Font Stabileşte corpul, stilul şi dimensiunea caracterelor
Exemple de valori 1= 3D, 0 = plat True, False caractere True, False MS Sans Serif, Bold, 12
- Etichete - sunt controale grafice folosite pentru a afişa text pe care utilizatorul nu îlpoate modifica direct ci doar cu ajutorul instrucţiunilor (codului). Pentru ca eticheta să afişeze corect linii multiple de diverse lungimi se vor stabili proprietăţile AutoSize şi WordWrap la valoarea True. - Casete de text sau TextBox-uri sau casete de editare, sunt utilizate pentru a afişa
informaţii introduse de utilizator la rulare sau asociate controlului prin program. Accesul la textul afişat se obţine prin stabilirea sau citirea proprietăţii Text a controlului, ceea ce poate face fie direct în faza de proiectare, fie prin cod utilizând notaţia cu punct. Exemplu de citire: sTextCaseta1= txtCaseta1.Text (dacă a fost creată o casetă de text numită txtCaseta1). Pentru a afişa mai multe linii de text într-o casetă de text, proprietatea MultiLine trebuie să fie selectată pe valoarea True. Dacă o casetă de text multilinie nu conţine o bară de derulare orizontală, textul va fi împărţit automat pe rânduri chiar dacă caseta este redimensionată. Barele de derulare se stabilesc cu proprietatea ScrollBars: Horizontal, Vertical, Both, None. Dacă proprietatea MultiLine este True, se poate utiliza proprietatea Alignment pentru a alinia textul la stânga, la dreapta, sau în centrul zonei, iar dacă MultiLine este False, Alignment nu are efect. Implicit textul este aliniat la stânga Proprietăţi uzuale ale unei casete Text Box Proprietate Appearance Border Style Font PasswordChar SelStart SelLength Tag
Descriere Selectează aspectul 3D sau plat Precizează tipul chenarului
Exemplu de valori 1= 3D, 0 = plat 0 - fără chenar, 1 - chenar simplu Stabileşte corpul, stilul şi dimensiunea MS Sans Serif, Bold, 12 caracterelor Ascunde textul cu un singur caracter Ex. * sau # Poziţia iniţială pentru selectarea numai la rulare textului Precizează lungimea textului selectat numai la rulare Memorează informaţii suplimentare orice expresie şir 49
Proprietăţile SelStart şi SelLength sunt disponibile numai la rulare şi deci nu vor fi afişate în fereastra Properties a casetei de text. Proprietatea Tag poate stoca informaţii suplimentare, ca de exemplu parola sistemului în faza de proiectare. - Butoane de opţiune (butoane radio) (Option Button) - afişează o opţiune care poate fi activată s-au dezactivată (•,o), funcţie de valoarea True sau False a proprietăţii Value a butonului. În general butoanele de opţiune se utilizează în grupuri (mai multe butoane) afişate într-un cadru - ca listă de opţiuni ce se exclud reciproc. Toate butoanele de opţiune afişate într-un recipient (cadru) se comportă ca un grup, deci numai unul singur poate fi activ la un moment dat (întâi se desenează cadrul şi apoi se depun butoanele în cadru desenarea ulterioară a cadrului nu are nici un efect asupra grupului). Prin intermediul proprietăţii Caption fiecărui buton i se poate ataşa un text ce va fi afişat imediat în dreapta butonului. Fiecărui buton i se poate ataşa cod ca de exemplu: If optButon1.Value = True Then MsgBox "Buton selectat" ′ Testează starea curentă a butonului optButon1 Else MsgBox "Buton neselectat" End if - Casete de validare - afişează o casetă care poate fi activată sau dezactivată ( , ). Se pot grupa mai multe casete de validare într-un cadru, însă spre deosebire de butoanele de opţiune, pot fi active mai multe casete din grup la un moment dat. Prin proprietatea Caption se poate afişa text explicativ în dreapta casetei ca mai jos: Select Case chkCv1 Case 0 VMsg = "Nebifată" Case 1 VMsg = "Bifată" Case 2 VMsg = "Indisponibilă" End select MsgBox VMsg - Cadre - oferă posibilitatea de a grupa controale înrudite (butoane de opţiune, casete de validare). Întâi se desenează cadrul şi apoi controalele. - Casetă cu listă (list box) afişează o listă de articole din care utilizatorul poate selecta unul sau mai multe. Pentru a prelucra articolele selectate se utilizează evenimentul Click sau Double Click ale casetei cu listă.
50
Exemplu: Private Sub lstLista1_Dblclick( ) ′ Afişează articolul selectat din caseta cu listă txtSelectie = lstLista1 în caseta de text txtselectie End Sub Proprietatea ListCount a unei casete cu lista returnează numărul de articole din listă, iar proprietatea ListIndex determină articolul curent selectat astfel: ListIndex = 0 pentru primul articol din listă = ListCount -1 pentru ultimul articol din listă = -1 dacă nu a fost selectat nici un articol din listă Pentru a selecta mai multe articole din listă se utilizează proprietatea Multiselect astfel: MultiSelect = 0 - nu sunt admise selecţii multiple (implicită) 1 - selecţie simplă (executare click cu mouse sau apăsare tastă spaţiu duce la selectarea sau deselectarea unui articol din listă; se pot utiliza săgeţi pentru mutarea selecţiei de la un articol la altul. 2 - selecţie multiplă (se apasă shift şi apoi click cu mouse sau utilizare săgeţi pentru a selecta articolul următor adăugat la elementul selectat anterior.Pentru selecţii multiple de articole neadiacente se utilizează tasta Ctrl şi Click cu mouse pe articol. Proprietatea Selected pe valoarea True sau False specifică dacă un articol din listă este selectat sau nu. Exemplu de cod ataşat: iNr = lstlista1.ListCount - 1 ′ afişează toate articolele selectate din lista (caseta cu lisa) lstLista1 For x = 0 To iNr If lstLista1.Selected(x) = True Then MsgBox lstLista1.List(x) End If Next Pentru a adăuga articole listei se utilizează metoda AddItem - Casete combinate (ComboBox) - combină facilităţile unui TextBox cu cele ale unui ListBox (conţine o casetă cu listă şi o casetă text). Proprietăţi şi metode comune ale casetelor cu listă şi casetelor combinate. Proprietate ListCount ListIndex List
Semnificaţie Nr. articole ale listei
Exemplu de utilizare iOpţiune = lstLista1.ListCount -1 Indexul numeric al articolului curent lstLista1.ListIndex = 3 Asociată cu indexul returnează articolul sArt3 = lstLista1.List(3) curent din listă
51
Selected Sorted
Are valoarea True dacă este selectat If lstLista1.Selected(3) Then articolul … Lista va fi sortată dacă valoarea lstLista1.Sorted = True proprietăţii sorted este True
Metode AddItem
Semnificaţie Adaugă listei un articol de tip şir
Clear RemoveItem
Elimină toate articolele din listă Elimină un singur articol din listă
Exemplu de utilizare lstLista1.AddItem = "Ionescu Ion" lstLista1.Clear lstLista1.RemoveItem 5
Utilizarea matricelor - variabile multidimensionale Dim sStudenti(15) As String sStudenti(0) = "Ionescu Ion" …………………………….. sStudenti(14) = "Popescu Vasile" For iIndex = 0 To 14 MsgBox sStudenti(iIndex) Next # Funcţia UBound(sStudenti) returnează numărul de elemente ale matricii (tabloului) Studenti. Exemplu de utilizare casete cu listă: Private Sub frmForma1_Click( ) Dim sStudenti(15) As String
′ Declară matricea sStudenti de 15 elemente ‘ Iniţializează elementele matricii
sStudenti(0) = "Ionescu" sStudenti(1) = "Florescu" ……………………….. For iC = 0 To Ubound(sStudenti) - 1 lstLista1.AddItem (sStudenti(iC)) Next
′ Adaugă fiecare element al matricii ca articol în caseta cu lista lstLista1 ′ Funcţia Ubound returnează numărul de elemente ale matricii ′ Selectează primul articol din listă
lstLista1.ListIndex = 0
- Bare de derulare (orizontale şi verticale) permit parcurgerea unor liste mari. Ori de câte ori se efectuează click pe o bară de derulare se execută procedura evenimentului Change. Când se trage bara de derulare se declanşează evenimentul Scrool, iar la eliberarea de pe bara de derulare se execută evenimentul Change.
52
- Spinner (SpinButton) - permite incrementare sau decrementare numere, prin ataşare şi activarea unui buton spinner unei etichete sau unei casete de text. - Controale cu imagini – permit afişarea de imagini pe suprafaţa unei forme, putând utilza pentru aceasta două tipuri de controale şi anume: PictureBox şi Image. Controalele Image pot fi create din bara de instrumente Toolbox Controls, aceste controale prezentând şi avantajul că imaginile plasate în ele pot fi redimensionate prin stabilirea proprietăţii Stretch a controlului la valoarea True. Controalele Image nu acceptă grafică desenată în timpul rulării şi nu pot fi utilizate ca recipiente pentru alte controale. Controalele PictureBox acceptă grafică desenată în timpul rulării programului utilizând metodele Line, Circle şi Pset. Dacă grafica încărcată dintr-un fişier depăşeşte suprafaţa controlului PictureBox, grafica va fi trunchiată exceptînd situaţia în care proprietatea AutoSize are valoarea True. Fişierele imagine pot fi importate în controale Image sau PictureBox fie prin setarea proprietăţii Picture a controlulu, fie cu ajutorul funcţiei LoadPicture() în timpul rulării programului. Exemplu. Pentru a incărca fişierul imagine Poza.jpg din directorul C:\Imagini, în controlul Image care are numele (Name) imag1 se va scrie instrucţiunea: imag1.Picture = LoadPicture(“C:\Imagini\Poza.jpg”) Pentru a elimina imaginea dintr-un control imagine se va folosi funcţia LoadPicture fără nici un argument ca în exemplul de mai jos: imag1.Picture = LoadPicture() - Controale listă de fişiere, de unităţi de disc şi de directoare DriveListBox - permite selectarea, la rularea programului, a unei unităţi de disc DirListBox - afişează o listă ordonată a directoarelor şi subdirectoarelor de pe disc şi prin click cu mouse permite utilizatorului să navigheze prin directoare FileListBox - afişează fişierele din directorul specificat de proprietatea Path la rularea programului. 5.9. Referire celule dintr-o foaie de calcul tabelar în Visual Basic Se face astfel: Sheets(n).Cells(nr.rând, nr.coloană) Exemplu. Instrucţiunea Sheets(3).Cells (1,2) = "Ionescu" depune şirul 'Ionescu' în celula B1 (rând 1 coloana 2) din a treia foaie de calcul a registrului de calcul Excel curent. Pentru precizarea celulei (nr.rând, nr.coloană) se pot utiliza variabile în bucle For. Exemplu: For irand = 1 To 5 lstLista1.AddItem (Sheets(3).Cells(irand,2)) Next 53
adaugă în caseta cu listă lstLista1 cinci înregistrări din a treia foaie de calcul, coloana 2 (B) rândurile de la 1 la 5 din registrul de calcul curent. 5.10. Gestionarea unui proiect Resursele unui proiect sunt memorate într-un fişier al proiectului care în Visual Basic este un fişier cu extensia .RES. În cazul în care limbajul Visual Basic este utilizat din Excel, fişierul proiect este un fişier cu extensia .XLS. Componentele proiectului pot fi vizualizate selectând din meniul View opţiunea Project Explorer astfel:
În fereastra din stânga ecranului vor fi afişate componentele proiectului şi anume: componente Excel componente Visual Basic (Forms, etc.) după cum este ilustrat în ecranul care urmează:
54
5.11. Crearea şi extinderea meniurilor Limbajul Visual Basic permite crearea de meniuri personale pentru o aplicaţie cu ajutorul editorului de meniuri. Unei forme i se poate asocia o pictogramă prin stabilirea proprietăţii Icon a formei în faza de proiectare atribuind proprietăţii Icon un fişier cu formatul .ICO. Dacă nu se specifică o pictogramă, se va utiliza pictograma Visual Basic prestabilită pentru forme. Această pictogramă va apărea în colţul din stânga sus al formei. Aceste elemente ale limbajului nu pot fi create şi utilizate în Visual Basic sub Excel. 5.12. Realizarea programului executabil pentru aplicaţie (proiect) Programul executabil pentru o aplicaţie Windows (proiect) este un fişier executabil cu extensia .EXE care poate fi rulat în afara mediului de dezvoltare Visual Basic. Acest fişier împreună cu alte fişiere auxiliare necesare programului va fi livrat viitorilor utilizatori ai aplicaţiei şi va putea fi instalat şi executat sub sistemul de operare Windows. Crearea programului executabil poate fi realizată pentru un proiect creat sub Visual Basic (şi nu sub Excel ca în cazul de mai sus).
55
5.13. Baze de date, Gestionarul de date, controlul Data, obiecte Set de înregistrări, SQL pentru interogarea bazelor de date Gestionarea datelor în Visual Basic se realizează cu componenta Data Manager care este o extensie a programului Visual Basic ce permite crearea de baze de date Microsoft Jet (Access). O bază de date creată cu gestionarul de date Visual Basic poate fi manipulată cu programul Access şi o bază de date creată cu programul Access poate fi gestionată cu gestionarul de date al programului Visual Basic. De asemenea programul Visual Basic poate accesa în citire o bază de date de următoarele tipuri: Btrieve dBase III, IV FoxPro 2.0, 2.5 Paradox 3.X, 4.X O bază de date creată sub Visual Basic constă din unul sau mai multe tabele şi relaţiile dintre tabele memorate într-un fişier bază de date. Pentru crearea unei baze de date se selectează opţiunea New Database din meniul File al gestionarului de date. După crearea şi salvarea fişierului ce va conţine baza de date se deschide fereastra Database ce conţine următoarele bitoane de comandă: - Open – deschide o bază de date existentă şi afişează datele acesteia - New – crează un nou tabel în baza de date curentă - Delete – elimină un tabel din baza de date curentă - Design – afişează şi eventual modifică structura unui tabel existent - Attach – ataşează tabele la distanţă - Relations – defineşte relaţii între date din tabele diferite. Controlul Data este un control predefinit ce poate fi utilizat pentru conectarea unei aplicaţii Visual Basic la sursa de date selectată şi pentru legarea altor controale (casete de text, casete cu imagini, etc.) cu câmpuri din tabele ale bazei de date.astfel încât orice modificări efectuate în conţinutul acestor controale sunt automat înregistrate în câmpurile corespunzătoare din baza de date. Spre exemplu dacă un control casetă de text este legat de un câmp al bazei de date, atunci orice modificare a conţinutului casetei de text va fi automat efectuată în câmpul asociat din baza de date. Un obiect set de inregistrări Recordset este un set logic de înregistrări din baza de date cu ajutorul căruia pot fi accesate datele din baze de date multiple prin cod Visual Basic deci fără a utiliza controlul Data sau controale legate. O altă modalitate pentru interogarea, actualizarea şi gestionarea bazelor de date relaţionale o constituie limbajul SQL (Structured Query Language) ale cărui instrucţiuni pot fi utilizate în programe Visual Basic pentru accesarea şi gestionarea datelor din baze de date relaţionale.
56
Probleme rezolvate Se crează un registru de calcul Excel care conţine următoarele foi de calcul: - Sheet1 (Personal) – Lista personalului angajat, cu următoarele câmpuri: Marca Nume şi prenume Funcţia Salar tarifar orar
57
- Sheet2 (Pontaj) - Orele lucrate în luna…, cu următoarele câmpuri: Marca Nume şi prenume Total ore lucrate ( SUM(Ziua : Ziua31) ) Ziua 1 (ore lucrate) Ziua 2 (ore lucrate) … Ziua 31 (ore lucrate)
58
-Sheet3 (Retineri) – Lista reţineri în luna…, cu următoarele câmpuri: Marca Nume şi prenume Avans CAR Rate
59
- Sheet4 (Salarii) – Lista salariilor pentru luna…, ce conţine următoarele câmpuri: Marca Nume şi prenume Funcţia Tarif orar Ore pontate Salar realizat Reţineri Salar net
În foile de calcul Pontaj, Reţineri, Salarii, câmpurile Marca, Nume şi prenume sunt preluate prin referire din foaia de calcul Personal. De asemenea , câmpurile Funcţia, Ore pontate sunt preluate prin referire în foaia de calcul Salarii din foile de calcul Personal respectiv Pontaj, iar câmpul Reţineri în foaia Salarii se obţine prin sumarea câmpurilor Avans, CAR, Rate din foaia de calcul Reţineri. În acest mod orice modificare asupra datelor în foile de calcul Personal, Pontaj, Reţineri, se vor reflecta automat şi în foaia de calcul Salarii. Din editorul Visual Basic, să se creeze în foaia de calcul Salarii, un formular care să conţină butonul de comandă Calcul Salarii căruia să i se ataşeze codul Visual Basic care identifică
60
ultimul rând completat în foile de calcul, calculează şi depune rezultatele obţinute în câmpurile Salar Realizat, Salar Net din foaia de calcul Salarii utilizând formulele: Salar Realizat = Tarif Orar * Ore Pontate Salar Net = Salar Realizat – Retineri La execuţia formei prin click cu mouse-ul pe butonul Calcul Salarii se vor realiza operaţiile menţionate mai sus. Creare formă:
61
Codul Visual Basic ataşat butonului Calcul Salarii:
62
Execuţie formă:
63
Rezultatul obţinut după execuţia formei:
În continuare se extinde problema cu alte tipuri de controale astfel: În formularul Form1 se crează o casetă cu listă ListBox1 ce va conţine numele şi prenumele angajaţilor şi un control imagine Image1 în care se va incărca un fişier imagine. Codul Visual Basic pentru completarea casetei cu listă şi încărcarea imaginii va fi ataşat butonului de comandă Command Button1. În ecranele ce urmează sunt ilustrate noile obiecte create , codul visual basic şi rezultatul execuţiei formei.
64
Formularul Form1
65
Codul Visual Basic
66
Rezultatul execuţiei formei
67
Rezultatul execuţiei formei după setarea proprietăţilor BackColor şi Font ale casetei cu listă pe alte valori
68
Probleme propuse spre rezolvare 1. Să se scrie codul Visual Basic care să realizeze completarea tuturor cîmpurilor în foaia de calcul Salarii (se pleacă de la o foaie de calcul Salarii vidă), utilizând foile de calcul Personal, Pontaj, Retineri şi formulele de calcul menţionate mai sus. 2. Să se scrie codul Visual Basic pentru crearea foilor de calcul Pontaj, Retineri plecând de la foaia de calcul Personal (valorile efective pentru orele pontate şi reţineri urmând a fi preluate ulterior de la tastatură). Teste de verificare 1. Într-un mediu de programare Visual obiectele principale sunt: a) aplicaţiile b) formele şi controalele desenate în forme c) procedurile 2. În Visual Basic obiectele pot fi create: a) cu comanda Object din meniul Insert a programului Excel b) folosind barele cu instrumente c) din meniul Edit al editorului Visual Basic 3. În programarea orientată obiect şi dirijată de evenimente, majoritatea obiectelor răspund la: a) evenimente b) controale c) proprietăţi 4. Comportamentul unui obiect: a) este predefinit b) nu poate fi modificat de utilizator c) poate fi modificat de utilizator prin ataşare de cod corespunzător 5. Un obiect este definit de: a) un set de proprietăţi b) comportament 6. Proprietăţile descriu: a) acţiunile obiectelor b) obiectele prin intermediul datelor c) metodele prin intermediul codului asociat
69
7. În gramatica programării orientate spre obiecte: a) obiectele sunt verbe b) proprietăţile sunt adjective c) metodele sunt substantive d) obiectele sunt substantive e) metodele sunt verbe 8. Referirea proprietăţilor sau metodelor în cadrul codului scris în Visual Basic se poate face prin: a) numele proprietăţilor sau metodelor b) utilizarea notaţiei cu punct (nume obiect. Nume proprietate / metodă) 9. Proprietăţile unui obiect pot fi setate: a) numai în faza de proiectare utilizând fişa Properties b) numai prin program utilizând notaţia cu punct c) atât în faza de proiectare cât şi prin program 10. Metodele pot fi executate: a) atât în faza de proiectare cât şi în momentul execuţiei programului b) numai în momentul execuţiei programului c) numai în faza de proiectare 11. Pentru referirea unui obiect în scrierea codului se poate utiliza: a) numele dat obiectului în proprietatea Capture b) numele dat obiectului în proprietatea Name c) numele obiectului dat în proprietatea Capture, fie cel dat în proprietatea Name 12. O variabilă în Visual basic poate fi declarată: a) implicit utilizând sufixul b) explicit utilizând instrucţiunea Dim c) cu instrucţiunea Declare d) cu instrucţiunea Static 13. O variabilă locală poate fi făcută permanentă în interiorul unei proceduri dacă: a) este declarată cu instrucţiunea Dim b) este declarată cu instrucţiunea Static 14. O variabilă declarată cu instrucţiunea Static a) este vizibilă din orice punct al aplicaţiei b) îşi conservă valoarea însă este vizibilă numai în cadrul procedurii în care a fost declarată
70
15. Cel mai înalt domeniu de vizibilitate a unei variabile se defineşte cu instrucţiunea: a) Static b) Dim c) Global 16. Tipurile de date definite de utilizator pot fi declarate: a) la nivelul oricărei proceduri b) la nivel de formă c) numai în secţiunea General / Declaration a modului de cod 17. Funcţia InputBox este: a) o funcţie definită de utilizator pentru preluare date de la tastatură b) o funcţie a limbajului Visual Basic pentru preluare date într-o casetă de text predefinită c) o funcţie Visual Basic pentru afişarea valorii unei variabile 18. În limbajul Visual Basic structurile de ramificare pot fi descrise: a) cu instrucţiunea If….End If b) cu instrucţiunea Do….Loop c) cu instrucţiunea Select….End Select d) cu instrucţiunea For…..Next e) cu funcţia Iif(…) f) cu instrucţiunea If…Else If…EndIf 19. În limbajul Visual Basic structurile de ciclare pot fi descrise cu instrucţiunile: a) Select…End Select b) While…Wend c) For……Next d) If….ElseIf….EndIf e) Do…Loop 20. În Visual Basic pot fi definite următoarele tipuri de proceduri: a) macro - definiţii b) proceduri - subrutine c) macro- funcţii d) proceduri - funcţii 21. O procedură subrutină poate realiza: a) returnează o valoare b) efectuează o acţiune dar nu returnează nici o valoarea c) efectuează o acţiune şi poate returna o valoare
71
22. În definirea unei proceduri subrutină trebuie respectate condiţiile a) Începe cu instrucţiunea Sub b) Începe cu prima instrucţiune din corpul procedurii c) Continuă cu instrucţiunile din corpul procedurii d) Se poate termina cu instrucţiunea End Sub e) Se termină cu instrucţiunea End Sub f) În instrucţiunea Sub trebuie precizat numele procedurii g) Numele procedurii se va termina cu ( ) 23. În definirea unei proceduri funcţii trebuie respectate condiţiile: a) Începe cu instrucţiunea Sub b) Începe cu prima instrucţiune din corpul funcţiei c) Începe cu instrucţiunea Function d) Se poate termina cu instrucţiunea End Function e) Continuă cu instrucţiunile din corpul funcţiei f) În instrucţiunea Function trebuie precizat numele funcţiei şi argumentele încadrate între paranteze g) Se termină cu instrucţiunea End Function 24. O procedură de tip funcţie poate realiza: a) Efectuează o anumită operaţie b) Poate returna o valoare c) Efectuează o operaţie dar nu returnează nici o valoare d) Returnează o valoare e) Atât la definire cât şi la apelare parantezele sunt obligatorii 25. O procedură de orice tip (Sub sau Function): a) poate fi ataşată unui obiect grafic b) nu poate fi ataşată unui obiect grafic c) numai procedurile subrutină pot fi ataşate unor obiecte grafice d) numai procedurile de tip funcţie pot fi ataşate unor obiecte grafice 26. Se creează o casetă text (Text Box) numită txtCaseta1. Pentru a memora textul introdus în această casetă în variabila sv1 se scrie instrucţiunea: a) sv1 = txtCaseta1.Name b) sv1 = txtCaseta1.Text c) sv1 = Text d) sv1 = txtCaseta1.Capture 27. Pentru crearea unui grup de butoane de opţiune într-un cadru se procedează astfel: a) Se desenează mai întâi butoanele de opţiune b) Se desenează cadrul astfel încât să conţină butoanele de opţiune c) Se desenează cadrul şi apoi butoanele de opţiune în interiorul cadrului 72
28. Într-un grup de butoane de opţiune pot fi active la un moment dat: a) mai multe butoane din grup b) un singur buton din grup c) toate butoanele din grup d) nici un buton din grup 29. Într-un grup de casete de validare pot fi active la un moment dat: a) mai multe casete de validare din grup b) nici o casetă de validare din grup c) numai o singură casetă de validare din grup (restricţie impusă) d) toate casetele de validare din grup 30. Obiectele care pot constitui containere de controale (alte obiecte) pot fi: a) Formele b) Butoanele de comandă c) Cadrele (frame) d) Casetele cu listă (ListBox) e) Casetele combinate (ComboBox) 31. Adăugarea de articole unei casete cu listă (ListBox) se poate realiza: a) prin tastare text în interiorul casetei b) utilizând metoda AddItem c) prin setarea proprietăţi Text a casetei d) prin setarea proprietăţii Value a casetei 32. Referirea celulei C1, din a patra foaie de calcul a registrului de calcul Excel curent, în Visual Basic se face astfel: a) C1 b) Sheets(4).Cells(C1) c) Sheets(4).Cells(1,3)
73
Capitolul 6. Tendinţe actuale şi viitoare privind tehnologiile de programare Rezumat- se prezintă unele aspecte privind tehnologia de programare orientată agent şi realizarea sistemelor multiagent. Este definit conceptul de agent software, sunt prezentate domenii de utilizare ale agenţilor, exemplede agenţi şi limbaje de comunicare între agenţi. După 1990 are loc naşterea şi răspândirea celui de-Al Patru-lea Val al progresului determinat de revoluţia cunoaşterii cu accent pe cunoaşterea inconştientă deci cunoaşterea bazată pe intuiţie, imaginaţie şi capacitatea creativă a individului. Este perioada ce va fi caracterizată de realizarea şi utilizarea de maşini care “gândesc” destinate pe domenii (ex. Economia), în care managementul este privit ca instituţie centrală cu difuzarea sa fără frontiere într-o societate informaţională globală şi în care cunoaşterea este exploatată ca resursă economică sub deviza “creăm împreună”. 6.1. Inteligenţa artificială distribuită Datorită facilităţilor de comunicare dincolo de graniţe, spaţiu şi timp oferite de reţeaua Internet, economia noului mileniu poate fi privită [8] ca o “scenă digitală” în care noile afaceri devin e-bussines (afaceri electronice), comerţul devine e-commerce (comerţ electronic), apar noi servicii electronice (e-services) şi se nasc noi comunităţi de tip virtual (e-communities). În noua scenă cu calculatoare interconectate în reţele Internet, Intranet şi Extranet suntem “inundaţi de informaţie, dar flămânzi după cunoştinţe” [8] (John Naisbitt „Megatrends. Ten New Directions Transforming Our Lives”), viziunea lui Alvin Toffler în „Şocul viitorului” fiind mult mai sumbră, el avertizând asupra iminenţei unui nou „potop”, de această dată nu de apă, ci de informaţii. Apare deci şi se dezvoltă, în cadrul economiei digitale, o nouă piaţă şi anume piaţa digitală sau piaţa electronică în care trebuie acordată o importanţă tot mai mare noii resurse strategice care este informaţia, cunoştinţa. Principalii actori (componente) ai economiei digitale, în viziunea anumitor specialisti (Turban, s.a., 1999) [8] sunt: - Cumpărătorii/consumatorii - milioane de internauţi care navighează pe Web -potenţiali cumpărători ai bunurilor şi serviciilor oferite sau promovate pe Internet - Vânzătorii - sute de mii de magazine digitale care îşi prezintă milioane de produse pe Net - Produsele şi serviciile digitale - digitalizarea software-ului, a muzicii, a cărţilor, ziarelor şi revistelor, a filmelor ş.a., digitalizarea a nenumărate alte produse şi servicii - Companiile creatoare ale infrastructurii digitale - mii de firme implicate în asigurarea hardwareului şi software-ului necesar realizării infrastructurii specifice economiei digitale, care să permită dezvoltarea comerţului electronic - Intermediarii (agenţii) - un nou tip de actori care îşi oferă serviciile pe Web, rolul lor diferind de cel al intermediarilor obişnuiţi prin aceea că sunt implicaţi în crearea şi susţinerea pieţei „on-line”, ei ajutând consumatorii şi/sau vânzătorii în derularea tranzacţiilor electronice 74
Serviciile de suport - sute de astfel de servicii sunt disponibile, pornind de la cele care asigură securitatea până la cele care furnizează cunoştinţe - Creatorii de conţinut - sute de companii de tip multimedia orientate pe crearea şi actualizarea continuă a propriilor pagini Web, pecum şi a unor site-uri pentru diverse alte firme Fiecare din componentele economiei digitale prezentate mai sus are un rol bine definit în cadrul pieţei digitale / spaţiului electronic (marketspace) în care au loc tranzacţiile. Din prezentarea de mai sus se constată apariţia unui nou tip de actor pe scena digitală şi anume intermediarul sau agentul. Se impune astfel distribuirea inteligenţei artificiale în vederea realizării sistemelor de agenţi inteligenţi sau sistemelor multiagent care pot lua decizii într-o societate populată de agenţi inteligenţi artificiali sau umani care au propriile lor scopuri. Distribuirea inteligenţei artificiale este justificată [9] din următoarele motive: în mod natural activităţile şi cunoştinţele sunt distribuite spaţial extinderea cooperării om-maşină prin rezolvarea distribuită a problemelor descompunerea sistemelor complexe şi a bazelor de cunoştinţe aferente în subsisteme cooperative asigurând astfel modularitate şi flexibilitate sistemului precum şi timp de răspuns optim. necesitatea integrării aplicaţiilor de inteligenţă artificială deja existente, atât între ele cît şi cu componente de prelucrare clasică şi sisteme de gestiune a bazelor de date distribuite în modelarea comportamentului uman în cadrul aplicaţiilor de inteligenţă artificială trebuie avut în vedere faptul că comportamentul uman este un comportament social. Astfel, apare şi se dezvoltă o nouă tehnologie în realizarea programelor şi anume programarea orientată agent AOP (Agent-Oriented Programming), care constituie o modalitate de abordare în construcţia sistemelor multi-agent. -
6.2. Definirea conceptului de agent Conceptul de agent poate avea diverse semnificaţii în funcţie de domeniul în care este utilizat. Astfel existã agenţi în diverse domenii ca de exemplu: economie, ştiinţele sociale, biologie şi mai recent, în ştiinţa calculatoarelor. Exemple: agent de vânzări, agent de asigurări, agent agricol, agent inteligent, etc. În ştiinţa calculatoarelor, termenul de agent este folosit de obicei pentru a desemna o componentă software sau/şi hardware care este capabilă să acţioneze în interesul utilizatorului, pentru îndeplinirea cu precizie a unor sarcini (Nwana, H. S., 1996). Din punct de vedere software, un agent este un program care se comportã analog cu un agent uman, fiind capabil sã comunice în mod inteligent cu alţi agenţi software sau persoane. După unii cercetători de la IBM „Un agent este un software care ştie cum să facă lucrurile pe care le-ai face tu însuţi dacă ai avea timp.” (Janca, P.,1995) 75
Având în vedere multitudinea de roluri pe care le poate avea un agent, este dificil de dat o definiţie formală unanim acceptată a agentului şi de aceea în cele ce urmează se vor prezenta câteva puncte de vedere privind caracteristicile pe care le poate îneplini un agent. Un agent poate fi definit prin următoarele cracteristici de bazã [9]: Autonomie: opereazã fãrã intervenţie umanã, are iniţiative şi exercitã control asupra propriilor lui acţiuni. Agentul acceptã cereri de la utilizatori dar este cel care decide cum şi unde va satisface aceste cereri. Colaboreazã cu utilizatorul sau cu alţi agenţi pentru satisfacerea cererilor acestora, putând sã propunã modificãri sau sã cearã clarificãri suplimentare. Reactivitate: percepe mediul în care evolueazã (care poate fi lumea fizicã, un utilizator prin intermediul unei interfeţe, o colecţie de alţi agenţi sau reţeaua Internet) şi rãspunde în timp util la schimbãrile sesizate în acest mediu. Comunicare şi abilitate socialã: un agent trebuie sã fie capabil sã se angajeze în comunicãri şi dialoguri complexe cu alţi agenţi sau persoane pentru a obţine informaţii sau ajutor în satisfacerea scopurilor. În domeniul inteligenţei artificiale, conceptul de agent presupune şi alte caracteristici cum ar fi: noţiuni mentale (pãreri, dorinţe, obligaţii, opţiuni), raţionalitate, adaptibilitate şi învãţare cu menţiunea că nu existã agenţi inteligenţi care sã îndeplinească toate aceste caracteristici, însă cei mai mulţi cercetãtori recunosc cã cele amintite ar fi caracteristicile definitorii ale unui program agent faţã de un program obişnuit. Principalele caracteristici pe care le au majoritatea agenţilor software care se comercializează la ora actuală (numiţi şi agenti simpli sau slabi) [8] sunt: Autonomie - agentul operează sau realizează sarcini fără intervenţia directă a omului sau a altceva Comunicare - abilitatea de a interacţiona cu alţi agenţi sau persoane prin intermediul unui limbaj de comunicare specific agenţilor Reacţie - capacitatea de a reacţiona în mod selectiv la schimbările din mediu (monitorizând în permanenţă evenimentele, agentul ştie exact ce sarcină trebuie să execute la apariţia unui anumit eveniment) Iniţiativă - abilitatea de a nu reacţiona doar ca răspuns la mediu, ci din proprie iniţiativă Continuitate în timp - spre deosebire de programe, care se termină când procesarea este încheiată, agentul continuă să ruleze (fie şi numai în backgroud, monitorizând continuu evenimentele care îi vor declanşa acţiunea) Orientare spre un anumit scop - agentul acţioneaza astfel încât să-şi îndeplinească scopul, în interesul utilizatorului; sunt cazuri în care un agent poate chiar să modifice ţelurile sau să le stabilească de unul singur. Caracteristici suplimentare: - Mobilitate - capacitatea de a migra de la sine de la o aplicaţie la alta - Bunăvoinţă - se presupune că agentul nu are scopuri conflictuale şi că orice agent întotdeauna încearcă să facă ceea ce i se cere - Inteligenţă - capacitatea de a învăţa, de a-şi creşte performanţele în timp
76
Adaptabilitate - abilitatea de a se ajusta/adapta singur la obiceiurile, metodele de lucru şi preferinţele utilizatorului - Colaborare - posibilitatea de a lucra împreună cu alţi agenţi pentru îndeplinirea unui scop comun - Versatilitate - posibilitatea de a se angaja în sarcini diferite - Personalitate - capacitatea agentului de a manifesta atribute specific umane cum ar fi: cunoştinţă, crez, intenţie, obligaţie etc. Există specialişti care atribuie agentului chiar faţă umană, argumentând că, deşi agenţii sunt bucăţi de cod software, oamenilor le place să aibă de-a face cu ei ca şi cum ar avea de-a face cu alţi oameni. În cadrul cercetărilor efectuate la BT Labs, Nwana a identificat trei caracteristici generale ca fiind atribute primare ale unui agent: autonomie, cooperare şi învăţare. Spre deosebire de agenţii care îndeplinesc doar caracteristicile generale şi care sunt denumiţi agenţi “slabi”, agenţii care pe lângă caracteristicile generale posedă şi caracteristici suplimentare sunt denumiţi agenţi “complecşi” sau “puternici” sau agenţi “tari”. -
6.3. Clasificarea agenţilor Având în vedere multitudinea de agenţi software şi rolurile pe care le pot avea aceştia, o clasificare a agenţilor este dificil de realizat. În cele ce urmează este prezentată clasificarea agenţilor realizată de Hyacinth S. Nwana [8] având în vedere diverse criterii astfel: - după gradul de mobilitate (capacitatea de a se deplasa în cadrul anumitor reţele): agenţi statici şi agenţi mobili - după modul de comportament: agenţi deliberativi (au încorporat un model de raţionament simbolic, şi în vederea coordonării cu alţi agenţi se angajează în procese de planificare şi negociere) agenţi reactivi (nu posedă un model simbolic, intern al mediului lor şi drept urmare, pentru a răspunde la starea actuală a mediului în care se află ei acţionează adoptând tipul de comportament stimul/răspuns) - după rolurile lor (în cazul în care se poate desprinde un rol preponderent): agenţi de informare, agenţi de negociere, agenţi de interfaţă, etc.; - după arhitectură: agenţi simpli (unitari) şi agenţi hibrizi (care încorporează două sau mai multe filozofii într-un singur agent) - după numărul de sub-agenţi încorporaţi: agenţi omogeni (mono-agenţi) şi agenţi eterogeni (multi-agenţi) - după veracitate: agenţi sinceri (de încredere, care nu mint niciodată) şi agenţi mincinoşi (care mint intenţionat). Clasificarea după criterii poate fi extinsă dacă se are în vedere prezenţa sau absenţa caracteristicilor generale sau secundare ale agenţilor. O clasificare mai restrânsă a agenţilor propusă de Nwana este următoarea: 77
agenţi colaborativi, agenţi de interfaţă, agenţi mobili, agenţi de informaţii/Internet, agenţi reactivi, agenţi hibrizi şi agenţi inteligenţi. Modelul sau arhitectura agenţilor poate varia de la structuri foarte simple, de tip automate, cum este cazul agenţilor reactivi, pânã la structuri de cunoştinţe complexe, capacitãţi de raţionament şi decizie, structuri întâlnite în cazul agenţilor cognitivi, numiţi şi agenţi raţionali. Agenţii cognitivi conţin o reprezentare simbolicã explicitã a lumii şi sunt capabili sã ia decizii pe baza unui raţionament simbolic. Au scopuri fixate şi pot sã-şi modifice acţiunile în funcţie de schimbãrile din mediu şi interacţiunea cu alţi agenţi, în vederea realizãrii acestor scopuri. Fiecare agent cognitiv este [9] un sistem bazat pe cunoştinţe, cu un grad mai mare sau mai mic de elaborare şi care include întreaga metodologie asociatã acestor sisteme. În cazul sistemelor de agenţi cognitivi, inteligenţa sistemului este datã atât de suma comportamentelor inteligente individuale ale fiecãrui agent cât şi de inteligenţa rezultatã din comportamentul colectiv bazat pe interacţiune de tip social. Referitor la definirea şi utilizarea agenţilor eterogeni în 1992 a apărut o nouă disciplină denumită Intelligent and Cooperative Information Systems (ICIS), care are în vedere integrarea sistemelor informaţionale, a tehnologiilor bazelor de date, a inteligenţei artificiale ş.a. prin folosirea agenţilor digitali. 6.4. Aplicaţii actuale ale agenţilor. Domenii de utilizare. Cercetări în domeniul tehnologiei agenţilor sunt efectuate atât în centrele de cercetare din cadrul unor universităţi, cum ar fi: Massachusetts Institute of Technology (MIT), the University of London, cât şi în cadrul unor firme sau companii multinaţionale ca de exemplu: IBM, Microsoft, Oracle, Alcatel, Apple, AT&T, DEC, HP, Lotus, Sharp. Majoritatea cercetărilor sunt axate pe aplicaţii ale agenţilor obisnuiţi (basic agent applications) a căror rezultate sunt vizibile în timp relativ scurt spre deosebire de aplicaţii ale agentilor inteligenţi (intelligent agent systems) care necesită un timp mai mare de realizare şi ale căror rezultate nu sunt imediate. Exemple de agenţi obişnuiţi: - a genţi pentru prelucrare e-mail - a genţi pentru filtrare şi/sau căutare în articole de ştiri - a genţi pentru pregătirea unor întâlniri de afaceri prin consultarea agendelor electronice ale participanţilor. Crearea unor astfel de tipuri de agenţi constituie un prim pas pentru realizarea de aplicaţii integrate, în care aceşti agenţi să fie folosiţi ca „materiale de construcţie” (building blocks) pentru crearea în următorii ani a unor sisteme complexe integrate de agenţi, capabile să execute sarcini de nivel înalt (high-level tasks) pentru utilizatori, furnizori şi intermediari - cele trei straturi ale modelului. Coordonarea în cadrul unui astfel de sistem se realizează prin intermediul unui singur agent care deleagă sub-sarcini (sub-tasks) către alţi agenţi. Domenii reprezentative în care este utilizată tehnologia actuală a agenţilor (Hermans, B., 1997, Wagner, D.N., 2000, Nwana, H.S., 1996 ) [8]: 78
-
poştă şi mesagerie managementul reţelelor (de telecomunicaţii, energetice, de transport etc.) controlul traficului aerian (ex. 11 septembrie 2001) comandă şi control managementul accesului mobil managementul informaţiilor depozitarea datelor (data mining) baze de date inteligente colaborare managementul proceselor de muncă cu caracter repetitiv (workflow management) - afaceri electronice (licitaţii, managementul canalelor de aprovizionare şi de distribuţie etc.) - biblioteci digitale - educaţie - cercetare guvernamentală - divertisment (entertainment) - asistenţi digitali personali (PDA) - interfeţe inteligente pentru utilizator ş.a. Dintre aceste domenii/arii de aplicare a tehnologiei agenţilor, cele mai intens studiate în acest moment sunt: accesul (regăsirea) şi managementul informaţiilor; comerţul electronic şi colaborarea. Exemple concrete de agenţi: - Hoover – agent care furnizează o unică interfaţă utilizator pentru mai multe medii informaţionale (ştiri în timp real, baze de date „on-line”, etc.) - Agenţi ghizi (exempluWebWatcher) – conduce utilizatorul prin Web, oferind în acelaşi timp o experienţã personalizatã fiecãrui utilizator (sfătuieşte interactiv utilizatorul Web-ului privind legătura următoare pe care trebuie să o urmeze şi învaţă din reacţia utilizatorului la sfatul primit). - Agenţi index (exemple:Lycos, WebCrawler, InfoSeek) - efectueazã o cãutare masivã şi autonomã de informaţie în Web, prin inspectarea unui număr mare de documente (până la un milion de documente) şi creeazã un index de cuvinte gãsite în titlurile şi textul documentelor inspectate. Utilizatorul poate apoi interoga agentul despre documente ce conţin anumite cuvinte cheie, iar agentul index poate oferi rãspunsuri rapide care pot fi relevante sau nu pentru utilizator. - Agenţi FAQ (Frequently Asked Questions files). - ghidează utilizatorul pentru gãsirea rãspunsurilor la întrebãrile frecvente puse de utilizatori asupra unui anumit subiect. Aceste intrebări precum şi răspunsurile sunt memorate în aşanumitele fişiere FAQ create de diverse organizaţii sau grupuri din Internet. - Internet Softbot (software robot)– Căutare informaţii structurate pe Internet în baza cererilor furnizate de utilizator prin dialog într-un limbaj expresiv în cadrul unei interfeţe
79
convenabile astfel încât cea mai mare parte a structurilor din Internet devin transparente pentru utilizator. El poate monitoriza o serie de evenimente, cum ar fi utilizarea discului, activitatea utilizatorului, buletinele electronice de ştiri, servere FTP, şi comunicã utilizatorului rezultatul printr-un semnal sonor, un mesaj pe ecran sau un mesaj e-mail. De asemenea, agentul Softbot poate acţiona asupra mediului în care lucreazã, prin asigurarea compactãrii fişierelor dintr-un director, protejarea unor fişiere, compilarea fişierelor program, conversia documentelor dintr-un format în altul, accesul la baze date de diverse tipuri, prin apelul, în secventã, a diverselor programe adecvate. Plecând de la numele unei persoane, el poate determina adresa electronicã a acesteia. - Info Agent – căutare informaţii atât în documente de tip structurat, cât şi de tip nestructurat. Un domeniu de mare interes în care agenţii se vor impune spectaculos este Internetul care permite astăzi accesul direct a milioane de oameni pe autostrada informaţională ([9] “Internet Society” estimeazã cã existã peste 30 de milioane de utilizatori care accesează zilnic reţeaua Internet), care pot fi atât consumatori cât şi potenţiali furnizori de informaţie. Căutarea informaţiei despre un anumit subiect necesită identificarea şi investigarea unui număr mare de documente de pe Web, operaţii mari consumatoare de timp şi care pot fi realizate de agenţi competenţi numiţi agenţi Internet. Pentru a asigura accesul tuturor categoriilor de utilizatori, indiferent de calificare şi cunoştinţele de care dispun, la resursele informaţionale imense de pe Internet, viitoarea generaţie de agenţi Internet va fi [9] o combinaţie de modele cognitive şi reactive, având ca scop atât satisfacerea necesităţii de informare a utilizatorului cît şi transparenţa totalã a autostrăzii informaţionale. Deşi reţeaua Internet reprezintă un mare succes în unificarea resurselor informaţionale, structura sa actuală în care pot fi identificate două straturi şi anume: utilizatorii (consumatorii) de informaţie şi producătorii (furnizorii) de informaţie, nu este adecvată pentru activitatea de informare care presupune prelucrarea complexă a informaţiilor din multiple documente de pe Web independentă de utilizator. Pentru rezolvarea acestei probleme, una din cele mai promiţătoare propuneri este modelul în care activităţile desfăşurate pe Internet sunt împărţite pe trei straturi, denumit [8] modelul celor 3 straturi şi anume: 1. un strat pentru utilizatorii de informaţie (clienţii informaţionali) – defineşte cererea de informaţie 2. un strat pentru furnizorii (producatorii) de informaţie – defineşte oferta de informaţie 3. un nou strat aflat între primele două, denumit stratul de mijloc sau stratul intermediarilor, care să permită conectarea primelor două straturi prin cele mai bune căi sau modalităţi. În cadrul acestui model, agenţii au un rol important diferenţiat pe straturi după cum urmează: - Sarcinile agenţilor în cadrul primului strat sunt de a afla ce informaţii caută utilizatorii, dacă au anumite preferinţe în legătură cu informaţia de care au nevoie, etc.
80
- În cadrul celui de-al doilea strat sarcinile agenţilor sunt de a face un inventar al serviciilor şi informaţiilor oferite de către furnizori, de a ţine evidenţa noilor informaţii adăugate în reţea, etc. - Agenţii din stratul de mijloc au rolul de intermediari informaţionali între utilizatorii informaţionali (umani sau electronici) şi furnizorii de informaţii, sarcina lor fiind de mediere între agenţii celorlalte două straturi. Agenţii utilizaţi într-un astfel de model vor trebui concepuţi în baza unor standarde general acceptate, astfel încât să răspundă şi să reacţioneze în acelaşi mod prin utilizarea unui set standardizat de coduri suficient de flexibil pentru a permite construirea unor agenţi pentru sarcini neaşteptate sau imprevizibile în prezent. Referitor la domeniile de utilizare a tehnologiei agenţilor în viitor, cercetători în domeniu cred [8] că agenţii autonomi vor deveni în urmatorii 10 ani parte integrantă a celor mai multe sisteme de afaceri: astfel, cei de la IBM prevăd o vastă utilizare a agenţilor software în e-commerce: “Creăm o nouă categorie economică (a new economic species), parţial asemănătoare nouă ca imagine, dar semnificativ diferită de oameni”, “Agenţii software vor deveni actori în economie”, afirmă Jeff Kephart, managerul grupului care se ocupă de fenomenul agenţilor. (Scott,K., 2001). Utilizarea tehnologiei agenţilor conduce la apariţia unor probleme care vor trebui soluţionate prin măsuri legislative. Dintre aceste probleme sunt menţionate [8] (Nwana, H.S, 1996; Norman, D. 1994; Etzioni, O.; Weld, D., 1994) următoarele: - asigurarea intimităţii persoanelor pentru care lucrează agentul - responsabilitatea faţă de acţiunile agentului - siguranţa (să nu influenţeze lumea în mod distructiv) - limitarea consumului de resurse rare - vigilenţa (să nu permită acţiunile clienţilor cu urmări ce nu pot fi anticipate) - probleme de etică: autoidentificarea agenţilor, moderarea accesului pe anumite servere, limitarea accesului numai pe serverele alocate agentului, respectarea autorităţii administratorilor de servere, etc. 6.5. Sisteme multi-agent. Definiţie, clasificare, arhitecturi. Definiţiile, clasificarea şi arhitectura unui sistem multi-agent sunt prezentate în cele ce urmează conform [10]. Un sistem multi-agent (SMA) este un sistem distribuit format dintr-o colecţie de agenţi autonomi care interacţionează într-un mediu comun, fiecare agent având cunoştinţe, capacitãţi de acţiune şi scopuri proprii. Funcţie de tipurile de agenţi utilizaţi se pot identifica douã categorii de sisteme multi-agent inteligente şi anume: - SMA cu agenţi cognitivi, numite şi sisteme multi-agent cognitive - SMA cu agenţi reactivi, numite şi sisteme multi-agent reactive Sistemele multi-agent cognitive urmăresc sã simuleze aspecte ale comportamentului uman prin tratarea noţiunilor de scop, cooperare, competiţie, organizare în structuri sociale
81
şi stabilirea relaţiilor de dependenţã în aceste structuri, capacitate de învãţare şi autoperfecţionare. Un sistem multi-agent cognitiv reprezintă un sistem particular bazat pe cunoştinţe ce conţine o reprezentare simbolicã a cunoştinţelor despre lumea în care evolueazã fiind capabil sã ia decizii prin intermediul unui proces inferenţial de raţionament. Însă, spre deosebire de un sistem bazat pe cunoştinţe clasic, în cadrul unui sistem multi-agent, un agent reprezintã simbolic lumea atât prin convingeri, care sunt pãreri despre lume, eventual incomplete sau eronate, cât şi prin cunoştinţe care reprezintã fapte adevãrate despre acea lume. De asemenea, un agent trebuie sã fie capabil sã raţioneze atât despre propriile lui convingeri şi cunoştinţe cât şi despre cele ale celorlalţi agenţi cu care interacţioneazã întrun anumit mediu. Abordarea cognitivă a agenţilor, ridică o serie de probleme critice în special referitor la complexitatea de calcul şi dificultatea algoritmilor necesari prelucrãrilor simbolice. Un sistem multi-agent reactiv este un sistem în care agenţii sunt unitãţi simple de prelucrare, capabile sã reacţioneze la schimbãrile de mediu şi sã execute acţiuni simple corespunzător acestor schimbări. Un astfel de sistem este inspirat din organizarea şi activitatea comunitãţilor biologice de insecte. Astfel o albinã nu poate fi consideratã inteligentã însă comportamentul stupului în ansamblu şi modul de organizare a albinelor, executând acţiuni comune şi coordonate în vederea realizãrii scopului, prezintã elemente de inteligenţã. Adepţii sistemelor multi-agent reactive, criticând abordarea cognitivă, consideră că inteligenţa este situatã în lumea exterioarã şi nu la nivelul componentelor de prelucrare individuale, respectiv agenţii, comportarea inteligentã fiind un rezultat al interacţiunii dintre agenţi şi mediu iar inteligenţa este o proprietate a sistemului ca întreg. În acest sens, au fost propuse sisteme cu arhitecturi care modeleazã structura şi comportamentul colectivitãţilor de insecte, sisteme care ar putea fi realizate într-o abordare subsimbolică utilizând reţele neuronale sau algoritmi genetici. O altă direcţie de cercetare o constituie abordarea mixtă cognitiv-reactivă având în vedere avantajele şi dezavantajele fiecăreia dintre cele două categorii de sisteme multiagent. 6.6. Limbaje de comunicare între agenţi Forma cea mai simplă de comunicare între agenţi în cadrul unei arhitecturi reactive, este comunicarea bazatã pe schimbul de informaţii prin intermediul unei structuri de tip tablã ("blackboard") sau de resursã partajatã care este împãrţitã în diferite nivele de abstractizare corespunzãtoare diverselor nivele de rezolvare a problemelor (nivele de comportament) iar agenţii vor scrie sau citi informaţiile de pe nivelele corespunzãtoare acţiunilor lor. Având însă în vedere faptul că în cadrul unui sistem multi-agent agenţii interacţionează într-un mediu comun, comunicarea între agenţi este o problemă cheie însemnând mai mult decât un simplu schimb de mesaje. 82
Pe lângă primirea şi transmiterea de mesaje, un agent trebuie să fie capabil să deducă intenţia emiţătorului referitor la mesajul trimis ceea ce presupune utilizarea unei forme complexe de comunicare bazată pe teoria actelor comunicării (”theory of speech acts”) dezvoltată în cadrul unor cercetări din domeniul limbajului natural. Astfel, într-un act de comunicare se disting următoarele 3 aspecte: - exprimarea unei propoziţii (mesaj); - efectul intenţionat (aşteptat) de cel ce comunică mesajul; - efectul asupra destinatarului comunicării. Aceste modele ale dialogului uman au stat la baza structurării mesajelor schimbate între agenţi şi definirii protocoalelor de comunicare prin care se stabilesc acţiunile posibile ale agentului în fiecare moment al comunicãrii cu alţi agenţi. Pentru programarea sistemelor multi-agent s-au elaborat o serie de limbaje corespunzător celor două categorii de sisteme multi-agent după cum urmează: - limbaje agent slabe (ACTOR, TCL/TK, TELESCRIPT) pentru sisteme multiagent reactive; - limbaje agent tari (AGENT0, PLACA, Concurent METATERM, KQML, KIF, COOL) pentru sisteme multi-agent cognitive. Dintre aceste limbaje şi protocoale de comunicare între agenţi, bazate pe teoria actelor comunicãrii, cel mai cunoscut este KQML (Knowledge Querry and Manipulation Language) propus de ARPA (Advanced Research Projects Agency) în 1992, cu ultima versiune standardizată apărută la începutul anului 1997. KQML foloseşte limbajul KIF (Knowledge Interchange Format) pentru a descrie conţinutul informaţional al mesajului şi este o reprezentare ASCII a logicii cu predicate de ordinul întâi, într-o sintaxă apropriată de cea a limbajului LISP. Limbajul KQML şi KIF (cu succesorul lui SIF - Simple Knowledge Interchange Format) tind să devină la ora actuală un standard al comunicării în Sistemele Multi Agent cognitive. Limbajul COOL (COOrdination Language) a fost creat pentru coordonarea acţiunilor agenţilor cu ajutorul a noi performative adăugate la cele ale limbajului KQML. Activitatea de coordonare poate fi realizată spre exemplu de un agent “manager”. Exemple de primitive KQML: - (ask A) - emiţãtorul întreabã receptorul dacã A este o convingere a receptorului; - (tell A) -emiţãtorul comunicã receptorului convingerea sa A; - (achieve A) - emiţãtorul cere receptorului sã includã A în mulţimea lui de convingeri; - (deny A) - emiţãtorul comunicã receptorului cã nu crede A. În concluzie se poate afirma că sistemele multi-agent au apărut din următoarele considerente: - necesitatea modelării sistemelor de natură distribuită; - distribuirea controlului inteligent se impune natural deoarece cunoştinţele şi activitãţile sunt inerent distribuite spaţial; - capacitatea limitată a unui singur agent de a rezolva probleme complexe; - simularea comportamentului inteligent prin interacţiunea dintre componente (agenţi) fiecare având informaţii incomplete despre problemă şi mediu;
83
- descentralizarea resurselor. Pentru realizarea sistemelor multi-agent apare şi se dezvoltă o nouă tehnologie în realizarea programelor şi anume programarea orientată agent AOP (Agent-Oriented Programming).. Programarea orientată pe agenţi introdusã de Yoav Shoham odatã cu definirea limbajului AGENT0, reprezintă o specializare a programării orientate pe obiecte şi în care colecţiei de obiecte definite de stări şi care comunică între ele prin transmitere de mesaje îi corespunde o mulţime de agenţi caracterizaţi de stări mentale compuse din noţiuni mentale (convingeri, intenţii, obligaţii, angajamente, decizii, etc.). Odată cu apariţia conceptului de agent software se prefigurează [9] o nouă direcţie de programare şi anume programarea orientatã agent, în care obiectele vor fi înlocuite de agenţi, deci entitãţi dotate cu capacitãţi de percepţie, comunicare, raţionament şi decizie, iar programele vor fi scrise prin manipularea adecvatã a unei mulţimi de agenţi predefiniţi sau definiţi de utilizator. Probleme rezolvate 1. Enumeraţi principalele caracteristici ale economiei digitale: - scenă digitală în care se dezvoltă: e-service, e-comerce, e-bussines, e-comunities - apariţia unui nou actor: intermediarul sau agentul - apare şi se dezvoltă piaţa digitală - distribuirea inteligenţei artificiale şi realizarea de sisteme multi-agent 2. Un agent software este: a) un limbaj de programare b) un program care se comportã analog cu un agent uman, fiind capabil sã comunice în mod inteligent cu alţi agenţi software sau persoane. c) un software care ştie cum să facă lucrurile pe care le-ai face tu însuţi dacă ai avea timp răspuns corect b), c) 3. Caracteristicile de bază ale unui agent sunt: a) autonomie b) mobilitate c) reactivitate d) comunicare e) personalitate răspuns corect a), b), d) 4. După capacitatea de a se deplasa în cadrul anumitor reţele, agenţii se clasifică în: a) agenţi deliberativi b) agenţi statici c) agenţi inteligenţi 84
d) agenţi mobili răspuns corect d) Probleme propuse 1.
Un sistem multi-agent reactiv este: a) un sistem în care agenţii sunt unitãţi simple de prelucrare (agenţi simpli) b) un sistem bazat pe cunoştinţe c) un sistem inspirat din organizarea şi activitatea colectivităţilor de insecte
2.
Programarea orientată agent este: a) o metodă de programare în domeniul inteligenţei artificiale b) o nouă tehnologie în realizarea programelor c) o specializare a programării orientate pe obiecte în care obiectele vor fi înlocuite de agenţi, deci entitãţi dotate cu capacitãţi de percepţie, comunicare, raţionament şi decizie, iar programele vor fi scrise prin manipularea adecvatã a unei mulţimi de agenţi predefiniţi sau definiţi de utilizator. d) o tehnologie de programare pentru realizarea sistemelor multi-agent
3.
KQML este: a) un sistem multi-agent b) un limbaj de programare pentru sistemele multi-agent c) un limbaj de comunicare între agenţi bazat pe teoria actelor comunicării
85
GLOSAR Algoritm este o succesiune finită de paşi care trebuie parcurşi pentru rezolvarea unei probleme. Schema logică este o modalitate de reprezentare grafică a unui algoritm. Pseudocodul este o metodă de reprezentare a unui algoritm într-un limbaj pe de o parte mai apropiat de limbajul natural, iar pe de altă parte într-o formă care să permită transcrierea lui ulterioară într-un limbaj de programare. Stiva este o formă de organizare a datelor pentru care operaţiile de introducere şi scoatere a datelor se fac în vârful ei. Backtracking este o metodă folosită la rezolvarea problemelor pentru care soluţia problemei poate fi pusă sub forma unui vector S(x1,x2,…,xn), unde x10 A1, x20 A2, … ,xn0 An, mulţimile A1, A2, … , An sunt finite şi elementele lor se află într-o relaţie de ordine bine stabilită şi pentru aceste probleme nu există o altă metodă de rezolvare mai rapidă. Tehnica Greedy poate fi privită ca un caz particular al tehnicii backtracking în care se renunţă la mecanismul de întoarcere şi în plus se cere aflarea unei singure soluţii a problemei, soluţie care satisface un anumit criteriu de optim. Recursivitatea este mecanismul prin care un subprogram (funcţie, procedură) se autoapelează. Divide et impera este o tehnică care constă în descompunerea unei probleme în două sau mai multe probleme mai simplu de rezolvat, iar soluţia pentru problema iniţială se obţine prin combinarea soluţiilor problemelor rezultate prin descompunere. Algoritmi genetici sunt metode de căutare şi optimizare moderne, bazate pe principiile selecţiei naturale şi geneticii şi care acţionează asupra unei codificări a funcţiei obiectiv, efectuând operaţii de reproducere asupra unei populaţii de cromozomi, utilizând operatori genetici: selecţia, încrucişarea, inversiunea, mutaţia. Strategiile de evoluţie şi Programarea evolutivă – cunoscute şi sub denumirea de algoritmi evolutivi, pun accentul pe legătura comportamentală dintre părinţi şi urmaşi sau dintre diferite populaţii. Programarea evolutivă constă în estimarea modificărilor de mediu în vederea transformării predicţiilor într-un răspuns corespunzător acestor schimbări, în funcţie de scopul propus. Graf este o pereche ordonată G = (V,E), unde V = {x1, x2, … ,xn} este o mulţime finită şi nevidă numită mulţimea nodurilor sau a vârfurilor şi Eφ VxV ( E = {(xk,xp) / xk0 V, xp0 V}) o submulţime a produsului cartezian VxV numită mulţimea arcelor sau a muchiilor. Drum de la vârful xk la vârful xp, şi se notează d(xk,xp) este o succesiune de arce la fel orientate cu primul arc, cu proprietatea că extremitatea terminală a fiecărui arc coincide cu extremitatea iniţială a arcului următor, excepţie făcând extremitatea iniţială a primului arc şi extremitatea terminală a ultimului arc.
86
Drum elementar este un drum care are toate vârfurile distincte sau care nu trece de două ori prin acelaşi vârf. Drum hamiltonian este un drum elementar care întâlneşte toate vârfurile grafului o singură dată. Circuit este un drum cu proprietatea că extremitatea iniţială a primului arc coincide cu extremitatea terminală a ultimului arc. O buclă este un circuit de lungime 1. Lanţ de la vârful xp la vârful xk este o succesiune de muchii puse cap la cap (între două vârfuri există o muchie dacă între ele există cel puţin un arc; nu interesează orientarea arcelor). Lanţ hamiltonian este un lanţ care întâlneşte toate vârfurile grafului o singură dată. Ciclu este un lanţ finit care pleacă de la un vârf şi se întoarce la vârful cu care începe, adică este închis. Limbaj de programare permite descrierea unui proces de calcul alcătuit din mai mulţi paşi pentru rezolvarea unei probleme, fiecare pas fiind exprimat în comenzi elementare (instrucţiuni) ce vor fi executate de calculator. Limbaj-maşină este limbajul propriu unui tip de calculator. Limbaj de asamblare se înlocuiesc codurile numerice ale instrucţiunilor şi operanzilor cu coduri mnemonice. Translatorul este un program ce traduce un program sursă scris într-un anumit limbaj de programare întru-un program echivalent dintr-un alt limbaj, acest nou program numindu-se program destinaţie. Limbaje de nivel înalt limbaje mai apropiate de limbajul natural în care un program diferă foarte puţin de la un calculator la altul, fiind însă necesară prezenţa unui program numit compilator care sa traducă programul în instrucţiuni cod maşină. Programarea visuală şi orientată obiect permite generarea unui program şi a unor interfeţe utilizator prietenoase prin combinarea (manipularea) unor obiecte predefinite sau definite de utilizator şi ataşare de cod corespunzător. Limbajul Visual Basic reprezintă un mediu de dezvoltare care permite crearea de programe orientate spre obiecte şi conduse de evenimente. Evenimentele se produc ca urmare a unei acţiuni a utilizatorului (ex. evenimentul click corespunde apăsării butonului stâng al mouse-ului pe obiectul respectiv), sau în urma execuţiei codului programului, sau pot fi declanşate de către sistem. Un obiect este definit de un set de proprietăţi cum ar fi: dimensiune, culoare, poziţie pe ecran, comportament. O metodă este o procedură (succesiune de instrucţiuni) asociată unei anumite acţiuni a unui obiect O variabilă este o zonă temporară de memorie căreia i se dă un nume, şi care poate memora (stoca) un anumit tip de dată care poate fi modificată pe parcursul execuţiei programului. Domeniul unei variabile este zona programului în care variabila este vizibilă. 87
Agent software este un agent este un program care se comportã analog cu un agent uman, fiind capabil sã comunice în mod inteligent cu alţi agenţi software sau persoane. Un agent este un software care ştie cum să facă lucrurile pe care le-ai face tu însuţi dacă ai avea timp.” (Janca, P.,1995). Agenţi cognitivi au încorporat un model de raţionament simbolic, şi în vederea coordonării cu alţi agenţi se angajează în procese de planificare şi negociere. Agenţi reactivi nu posedă un model simbolic, intern al mediului lor şi drept urmare, pentru a răspunde la starea actuală a mediului în care se află ei acţionează adoptând tipul de comportament stimul/răspuns. Sistem multi-agent (SMA) este un sistem distribuit format dintr-o colecţie de agenţi autonomi care interacţionează într-un mediu comun, fiecare agent având cunoştinţe, capacitãţi de acţiune şi scopuri proprii.
88
Bibliografie 1.
4.
2.
Adrian Atanasiu, Cum se scrie un algoritm SIMPLU, Editura Agni, Bucureşti, 1993. Tehnici de programare, Tudor Sorin, Ed L&S INFOMAT, Bucure;ti, 1996.
3.
Horowitz E., Fundamentals of Programming Languages, Springer Verlag, 1983.
Şerbănaţi D. L., Limbaje de programare şi compilatoare, Ed. Academiei, Bucureşti, 1987. 5.
Bull M., Students’ Guide to Programming Languages, B. H. Newnes, 1992.
6.
Mark Steven Heyman, Bazele Visual Basic 4, Trad. Călin Suciu, Ed. Teora, 1996
7.
www.cs.ubbcluj.ro/disc/rmi034.htm – 11k
8.
[DANA02]. Prof.univ.dr.Doina Danaiata, asist.univ.drd. Camelia Margea, Rolul agentului într-o lume digitală. Competiţia pe scena economiei digitale. Scenarii, actori şi roluri. www.feea.uaic.ro/…/24_26_oct_2002/ziua2/sectiunea_III/ROLUL%20 AGENTULUI%20%CENTR-O%20LUME%20DIGITALA.pdf
9.
[FLAM98]. Agenţi inteligenţi Internet, Adina Magda www.byte.ro/byte95-04adi.html
10.
[SIMA98]. Dicţionar modern de informatică, “Sisteme multiagenţi”, Universitatea “Politehnica Bucureşti” www.cs.pub.ro/~dict/sisteme_multiagenti/ sisteme_multiagenti.html A. Kaufman, Metode şi modele ale cercetării operaţionale, vol. II, Ed. Ştiinţifică, Bucureşti, 1967.
12.
Donald E. Knuth, Arta programării calculatoarelor, Vol. 1, 2, 3, traducere de Mihaela Târpa, Ed. Teora, 2002.
11.
89
