Sunteți pe pagina 1din 106

UNIVERSITATEA SPIRU HARET

FACULTATEA DE MATEMATICĂ ŞI INFORMATICĂ

Modele matematice şi informatice în finanţe, asigurări şi burse de valori

LUCRARE DE
DISERTAŢIE

Îndrumător,

Prof. Univ. Dr. Albeanu Grigore

Absolvent,

Dumitru Marius

BUCUREŞTI

2010
UNIVERSITATEA SPIRU HARET

FACULTATEA DE MATEMATICĂ ŞI INFORMATICĂ

Modele matematice si informatice în finanţe, asigurări şi burse de valori

ANALIZA SERIILOR DE
TIMP

Îndrumător,

Prof. Univ. Dr. Albeanu Grigore

Absolvent,

Dumitru Marius

BUCUREŞTI

2010

1
DECLARAŢIE

Subsemnatul Dumitru Marius , absolvent al Programului de Studii


Universitare de Masterat: Modele Matematic şi Informatice în Finanţe, Asigurări şi
Burse de Valori denumirea programului Modele Matematic şi Informatice în Finanţe,
Asigurări şi Burse de Valori, organizat de Facultatea de Matematică şi Informatică,
Universitatea SPIRU HARET, Bucureşti, declar pe propria răspundere că lucrarea de
disertaţie cu titlul „ Analiza Seriilor de Timp” este rezultatul muncii mele, pe baza
cercetărilor mele şi pe baza informaţiilor obţinute din surse, inclusiv de pe Internet,
care au fost citate şi indicate, conform normelor etice, în note şi în bibliografie.

Declar că nu am folosit în mod tacit sau ilegal munca altora şi că nici o parte
din lucrare nu încalcă drepturile de proprietate intelectuală ale cuiva, persoană fizică
sau juridică.

Declar că lucrarea nu a mai fost prezentată sub această formă vreunei instituţii
de învăţământ superior din ţară sau străinătate în vederea obţinerii unui grad sau titlu
ştiinţific ori didactic.

Bucureşti,

Dumitru Marius

_________________________
(semnătura în original)

2
Abstract

Software products are very important in now a days especially in fields like
assurance, banking or stock exchange. To be updated with information is not enough,
it is necessary to have property tools to analyse every piece of data and to predict the
next step to succed. My thesis is dedicated to the time series analysis and to represent
into a chart any data which we are interested in. The second goal is to create a
program which can be updated very easy with new features or models of time series
analysis.

My study is structured in three chapters. In the first chapter, I describe


mathematical foundations regarding time series and some models of their. In the
second chapter I present details regarding implementation part. In the last chapter I
present user manual ot this software and a short presentation of the Net Beans
program, program where I developed the application.

The most important results obtained during this research and presented in the
second chapter is represented by the transformation of the mathematical model into a
software solution, easy to use by persons that haven’t studies/ specialized knowledge
regarding financial, assurance or stock exchange field

As final remark, my work can be continued by other studens which want to


make research in time series field and can develop only some Java classes and update
the application.

3
Cuprins
DECLARAŢIE ......................................................................................................... 2
ABSTRACT ............................................................................................................. 3
CUPRINS ................................................................................................................. 4
INTRODUCERE ...................................................................................................... 6
CAPITOLUL 1 – FUNDAMENTE MATEMATICE ................................................ 8
1.1 SERII DE TIMP ................................................................................................... 8
1.2 AUTOCOVARIANŢA ŞI AUTOCORELAŢIA ........................................................... 10
1.3 METODE DE EXTRAGERE A TRENDULUI ............................................................ 11
1. Metoda mediilor parţiale ............................................................................. 11
2. Metoda mediilor mobile ............................................................................... 12
1.4 MODELE DE SERII DE TIMP ............................................................................... 12
1. Modelul aditiv al seriilor de timp ............................................................... 12
2. Modelul multiplicativ al seriilor de timp..................................................... 13
3. Zgomotul alb.............................................................................................. 13
4. Mersul aleator (random walk) .................................................................... 14
5. Procese medie mobilă ................................................................................ 14
6. Procese autoregresive ................................................................................. 18
7. Procese mixate ARMA(p,q) ....................................................................... 19
8. Procese nestaţionare autoregresive şi de medie mobilă ARIMA(p,n,q) ....... 19
9. Modelul ARFIMA (AutoregressiveFractionallyIntegratedMovieAverage) .. 19
10. Seria integrată .......................................................................................... 20
11. Serii cointegrate ....................................................................................... 20
12. Procese ARCH (Autoregressive Conditional Heteroskedasticity) ............. 20
CAPITOLUL 2 - PROIECTARE ŞI IMPLEMENTARE......................................... 28
2.1 PROIECTARE .............................................................................................. 28
2.2 ŞABLOANE DE PROIECTARE ........................................................................ 33
2.2.1 Şablonul Command ............................................................................... 38
2.2.2 Şablonul Model – View - Controller ...................................................... 43
2.2.3 Şablonul Template ................................................................................ 51
2.3 IMPLEMENTARE ......................................................................................... 56
2.4 EXPLICITARE CLASELOR............................................................................. 61
About............................................................................................................... 61

4
ActionMethod .................................................................................................. 61
BrowseFile ...................................................................................................... 62
BrowseUpdate ................................................................................................. 63
Centru.............................................................................................................. 64
Copy_File ........................................................................................................ 65
Data_File ......................................................................................................... 66
ErrMsg ............................................................................................................ 66
Grafic .............................................................................................................. 66
Hdata ............................................................................................................... 68
IOData ............................................................................................................. 68
Logs ................................................................................................................ 72
Main ................................................................................................................ 73
MainWindows ................................................................................................. 73
SetData ............................................................................................................ 74
UpdateApp ...................................................................................................... 75
UserManual ..................................................................................................... 76
CAPITOLUL 3 - UTILIZARE ................................................................................ 78
3.1 MANUAL DE UTILIZARE.............................................................................. 78
3.1.1 Series_Analysis ..................................................................................... 78
3.1.2 Export ................................................................................................... 83
3.1.3 View Logs ............................................................................................. 86
3.1.4 History Data .......................................................................................... 87
3.1.5 Update................................................................................................... 88
3.1.6 Browse .................................................................................................. 89
3.1.7 Load Data ............................................................................................. 90
3.1.8 Grafice .................................................................................................. 92
3.1.9 User Manual.......................................................................................... 92
3.1.10 About ................................................................................................ 93
3.1.11 Eroare ................................................................................................ 94
3.2 NETBEANS IDE 6.8 ................................................................................... 95
CONCLUZII......................................................................................................... 103
BIBLIOGRAFIE................................................................................................... 104

5
INTRODUCERE

De ce am ales acest program de masterat? Motivul a fost acumularea unor cunoştinţe


mai vaste asupra domeniilor financiar, bancar şi al asigurărilor. Iubind informatica şi
concretizând acest lucru prin proiectele pe care le-am realizat ca free-lancer, dar şi
pentru a face faţă solicitărilor impuse de jobul actual (precum şi cele pe care le-am
avut) m-au determinat să aleg cursurile acestui program de masterat.

În această lucrare este prezentată o privire de ansamblu asupra modelelor seriilor de


timp precum şi un produs software care realizează acest lucru automat.

Deoarece seriile de timp se regăsesc în viaţa cotidiană a fiecăruia dintre noi, uneori
chiar fără să ştim, am dezvoltat aplicaţia cât mai general pentru a acoperi o gamă cât
mai mare de situaţii.

Deşi iniţial acest proiect a avut un scop pur didactic, fiind conceput pentru a-mi
demonstra cunoştinţele dobândite, acum produsul Analiza Seriilor a depăşit această
graniţă şi, în prezent, nucleul aplicaţiei este folosit în aplicaţiile dezvoltate de
compania în care lucrez pentru analiza diverselor informaţii, printre care şi evoluţia
cursului valutar.

Scopul didactic al proiectului nu se rezumă doar la prezentarea şi evaluarea


cunoştinţelor propriei persoane, ci şi ale altor masteranzi viitori. La îndemnul
domnului profesor Albeanu am concept acest proiect uşor de actualizat/îmbunătăţit cu
noi metode de analiză. Astfel viitori masteranzi care doresc sa imi continue proiecul
nu au altceva de făcut decât să scrie clasele sursă în Java şi să actualizeze programul
prin opţiunile disponibile.

Nucleul proiectului Analiza Seriilor se bazează în proporţie de 50% pe nucleul


aplicaţiei Comerţul Electronic ce reprezintă proiectul pentru propria lucrarea de
licenţă susţinută în anul 2008 sub îndrumarea Prof. Univ. Dr. Bălănescu Tudor.

În aplicaţia Analiza Seriilor am implementat reprezentarea a două metode de


extragere a trendului, modelul Mers Aleator (Random Walk), precum si o
reprezentare simplă (un grafic) a unor date într-un format/desen 2D (axele XOY).

6
Cele două metode de extragere a trendului sunt:

- metoda mediilor parţiale – considerând grupele compuse din câte un


element/o valoare din mulţimea de valori analizată

- metoda mediilor mobile – considerând un subset de valori compus din fiecare


3 elemente consecutive ale mulţimii analizate.

Toare reprezentările grafice sunt bazate pe clasa Grafic (2.4 Explicitarea claselor -
Grafic) având doar unele modificări.

În cazul modelului Mers Aleator, graficul va conţine atât reprezentarea grafică a


punctelor/valorilor, cât şi două grafice: cu eroarea aleatoare pozitivă, respectiv
negativă.

7
CAPITOLUL 1 – FUNDAMENTE MATEMATICE

În acest capitol sunt prezentate fundamentele matematice care stau la baza acestui
proiect. Înainte de a se începe implementarea acestei aplicaţii a trebuit să am la
dispoziţie o minimă documentaţie despre ceea ce va trebui sa fac. Aceste lucruri sunt
expuse în acest capitol.

1.1 Serii de timp

 Zgomotul alb
 mersul la întâmplare
 procese medie mobilă (MA(q))
 procese autoregresive (AR(p))
 procese mixate (ARMA(p,q))
 seria integrată (ARIMA(p,n,q), ARFIMA(p,d,q))
 serii cointegrate, procese ARCH, GARCH.

Seria cronologică reprezintă un set sistematizat de valori ale unei varibile


măsurate la momente sau intervale de timp egale şi successive. Seria cronologică
este numită şi serie dinamică sau serie de timp. Din punct de vedere matematic,
seria de timp este o realizare a unui proces stocastic X t t unde t  Z sau unei
mulţimi din Z, iar spaţiul stărilor procesului (adică X t  ,   ) este mulţimea
R sau o submulţime a sa.
Exemple de serii cronologice :
1). Cifra de afaceri anuală a unei firme de-a lungul unui deceniu.
2). Numărul şomerilor înregistraţi trimestrial în timpul unei guvernări de 4 ani.
3). Numărul poliţelor încheiate de o societate de asigurări în fiecare trimestru
dintr-o perioadă de 5 ani.
4). Încasările zilnice ale unui supermarket pe o perioadă de o lună.
5). Numărul de transporturi efectuate în fiecare trimestru din ultimii 3 ani de
către o firmă de transporturi auto internaţionale.
Analiza seriei de timp, identificarea, evaluarea şi separarea componentelor oferă
informaţii privind :

8
i) trendul, adică existenţa unui sens evolutiv dominant, care se manifestă
îndeosebi în condiţii de normalitate ale desfăşurării procesului;
ii) apariţia unor oscilaţii periodice sistematice, cu şanse mari de a se repeta şi în
viitor, atât ca sens cât şi ca amploare;
iii) aspectul previzibil al evoluţiei unor procese, ca răspuns la unele abateri din
trecut;
iv) identificarea factorilor neesenţiali, permiţând eventuala eliminare a lor;
v) caracterul inerţial al desfăşurării unor procese.
O primă clasificare a seriilor de timp este dată de împărţirea lor în serii
staţionare şi serii nestaţionare.

Seria staţionară este seria ale cărei valori oscilează în jurul unui nivel de referinţă
(de echilibru). Vom nota cu xt valoarea de la momentul t şi cu X t variabila aleatoare
de la momentul t a cărei realizare este xt . În limbaj matematic, seria este staţionară
dacă procesul stocastic X t t este staţionar, adică are media şi dispersia constante, iar
covarianţa variabilelor din proces depinde numai de distanţa dintre momentele de
timp la care sunt înregistrate. Aşadar, avem :
M  X t   m, D 2  X t    2 şi Cov  X t , X t  k    k ,  t .
Analize mai amănunţite disting o staţionaritate slabă şi o staţionaritate strictă.
Procesul stocastic X t tT este complet caracterizat dacă pentru orice întreg n  1 şi
orice mulţime de indici distincţi t1 , t 2 ,..., t n este cunoscută funcţia de repartiţie
 
Ft1t2 ...t n  x1 , x 2 ,..., x n   P X t1  x1 , X t2  x 2 ,..., X tn  x n .
Definiţia 1. Procesul stocastic X t t este strict staţionar dacă
Ft1  h,..., t n  h  x1 ,..., x n   Ft1 ,..., t n  x1 ,..., x n  ,  h  0 şi pentru orice mulţime finită de
indici t1 , t 2 ,..., t n .
Definiţia 2. Procesul stocastic X t t este slab staţionar (sau, mai simplu spus,
staţionar) dacă momentele sale de ordin unu şi doi sunt finite, M  X t   m,  t şi
Cov  X t , X t  h   Cov  X s , X s  h  pentru orice t,s şi h (deci, covarianţa este funcţie
numai de distanţa dintre variabile). Pentru staţionaritatea slabă se mai folosesc şi
sintagmele : „staţionară de ordinul doi”, „staţionară în covarianţă” sau „staţionară în
sens larg”.
Observaţie : Dacă X t tT este o serie de timp strict staţionară cu M X t2   (adică  
momentele de ordin doi sunt finite), atunci dispersia lui X t este o constantă pentru
toţi t. De asemenea, un proces stocastic strict staţionar cu primele două momente
finite este şi slab staţionar. În economie majoritatea seriilor cronologice privind
preţurile, masa monetară, consumul etc. nu sunt staţionare, sunt nestaţionare,

9
deoarece prezintă tendinţe de creştere sau de scădere în timp (media lui X t depinde
de momentul t).
În raport cu modalitatea în care se elimină tendinţa din seria de date avem :
1). Serii nestaţionare TSP („trend stationary processes”) sunt serii care prin
îndepărtarea tendinţei sunt transformate în serii staţionare. Notând cu x̂t tendinţa şi
cu xt'  xt  xˆ t rezultă că seria xt'   t
este staţionară.
2). Serii nestaţionare DSP („difference stationary processes”) sunt serii care se
transformă în serii staţionare prin calculul diferenţelor de ordinul întâi
y t'  y t  y t  y t 1 sau de ordinul doi xt'   2 xt  x t  xt 1 . Prin aceste diferenţe
se elimină şi trendul. Evident, se pot defini diferenţe şi de alt ordin, inclusiv
fracţionar. O modalitate pentru a stabili dacă o serie este de tip TSP sau DSP este dată
de testul Dickey-Fuller. Pentru aceasta se pleacă de la un model de forma
xt  a 0  a1  t  b  xt 1   t , unde a0 , a1 şi b sunt parametri iar  t este o variabilă
aleatoare de medie zero şi dispersie  2  0 , t  1,2,..., n. Dacă a1  0 şi b  1 atunci
seria este de tip DSP. Dacă a1  0 şi b  1 , atunci seria este de tip TSP. Evident
a1  0 şi b  1 implică xt  xt  xt 1  a 0   t care este un proces staţionr oscilând
aleatoriu în jurul lui a 0 .

1.2 Autocovarianţa şi autocorelaţia

Fiind dată o serie de timp staţionară, X t t , numărul  k   Cov  X t , X t  k  este numit a k


autocovarianţă, iar şirul  k k văzut ca o funcţie definită pe Z, este numit funcţia de
 k 
autocovarianţă a lui X t t . Pentru  0  0 definim  k   numit a k autocorelaţie
 0 
a lui X t t , se mai notează Corr  X t , X t  k  . Evident  0  1 şi  k   1,  k . Şirul
 k k văzut ca funcţie definită pe Z este numit funcţia de autocorelaţie a lui X t t . Este
mai convenabil de lucrat cu autocorelaţiile deoarece ele sunt invariante la scală.
Să considerăm X t tZ un proces stocastic staţionar. Pentru funcţia autocorelaţie avem
următoarele proprietăţi.
P.1. Funcţia de autocorelaţie este pară în raport cu lag-ul, adică avem  k     k ,  k .

Demonstaţie. X t t staţionar implică  k   Cov  X t , X t  k   Cov  X t k , X t  


 k    k 
Cov  X t , X t  k     k  , rezultă  k       k 
 0   0

10
P.2.  k   1
Demonstraţie. Avem Var 1  X t   2  X t k   0,  1 ,  2 . Rezultă
12  Var  X t    22  Var  X t  k   2  1   2  Cov  X t , X t  k  
12   2  22   2  2  1   2   k   0
Luând 1   2  1 obţinem 2   2  2   k   0 ,  k    2 şi
 k   k    2
 k     2  1
 0  2 
 k 
Luând 1  1 şi  2  1 obţinem 2 2  2 k   0 ,  k    2 ,  k   
 0 
 k   2
  1 . Aşadar  1   k   1 .
2 2

1.3 Metode de extragere a trendului


1. Metoda mediilor parţiale constă în următorii paşi :
Pasul 1 : Se separă datele seriei în două grupe : una inferioară şi alta superioară.
Pasul 2 : Se calculează media aritmetică a fiecărei grupe.
Pasul 3 : Se determină mediana momentelor de timp ale fiecărei grupe. Aceasta
reprezintă momentul de timp corespunzător mediei aritmetice. Pentru
fiecare grupă, se reprezintă grafic punctul de ordonată media aritmetică şi de
abscisă momentul de timp corespunzător.
Pasul 4 : Dreapta determinată de cele două puncte, reprezentate grafic, constituie
trendul cerut.

Exemplul 1. Numărul contractelor de asigurare încheiate de o societate de asigurări


în primele 10 luni ale anului 2009 este dat în tabelul :
Ianuarie Februarie Martie Aprilie Mai

2000 2400 2600 2500 2300

Iunie Iulie August Septembrie Octombrie

2800 3000 3500 3200 3400

Utilizând metoda mediilor parţiale, să se extragă trendul.


Soluţie. Primele 5 luni formează grupa inferioară având media y1  2360 cu

11
momentul de timp corespunzător luna martie. Celelalte luni formează grupa
superioară având media y 2  3180 cu momentul luna august.

2. Metoda mediilor mobile constă în calcularea mediei aritmetice a fiecărui subset


de q valori consecutive ale seriei date. Mărimea q este denumită perioada mediilor
mobile. Formarea unui nou subset presupune scoaterea primei valori din subsetul
anterior, păstrarea celorlalte q-1 valori şi introducerea în subset a următoarei valori
din şirul valorilor seriei date. Mediile mobile calculate reprezintă chiar componentele
(valorile) trendului seriei cronologice date.
La stabilirea perioadei mediilor mobile trebuie avută în vedere necesitatea ca aceasta
să coincidă cu lungimea ciclului natural al seriei. De exemplu, la determinarea
trendului numărului de şomeri înregistraţi trimestrial de-a lungul mai multor ani,
perioada mediilor mobile va fi 4; la determinarea trendului încasărilor zilnice ale unui
supermarket, înregistrate pe mai multe luni, perioada mediilor mobile va fi 7.

În cazul exemplului de la punctul 1, mediile mobile de perioadă 5 sunt :

xt 2000 2400 2600 2500 2300 2800 3000 3500 3200 3400

Totaluri 11800 12600 13200 14100 14800 15900

mobile

Medii 2360 2520 2640 2820 2960 3180

mobile

În cazul în care mediile mobile sunt folosite pentru reprezentarea grafică a trendului
şi se vrea reprezentarea valorilor acestuia în anumite momente de timp, există o
metodă de centrare a mediilor mobile, metodă care necesită calculul mediilor
aritmetice pentru perechile succesive de medii mobile.

1.4 Modele de serii de timp


1. Modelul aditiv al seriilor de timp
Y T S R
unde : Y este valoarea cunoscută a seriei de timp,
T este componenta trend,
S este componenta sezonieră,
R este componenta reziduală.

12
2. Modelul multiplicativ al seriilor de timp
Y T S R
unde : Y, T, S, R au semnificaţia mai sus.

3. Zgomotul alb
O serie de timp X t t formată din variabile aleatoare necorelate, cu media zero şi
dispersia  2  0 , se numeşte zgomot alb. Evident, ea este staţionară, având funcţia
 2 , k  0
de autocovarianţă  k    ,
0, in rest
1, k  0
şi funcţia de autocorelaţie  k   
0, in rest

   
Se notează WN 0,  2 (White Noise), deci X t  ~ WN 0, 2 . Zgomotul alb mai este
denumit şi proces pur aleator. Dacă elementele lui X t  sunt i.i.d. (independente şi
identic repartizate), atunci seria de timp este strict staţionară (se mai scrie
 
X t  ~ IID 0,  2 ). Când X t -urile au repartiţia normală, spunem că zgomotul alb
este gaussian. În cazul unui zgomot alb gaussian cele două definiţii privind
staţionaritatea coincid, deci seria este atât staţionară cât şi strict staţionară. Un proces
 
X t  este un zgomot alb cu media m dacă X t  m ~ WN 0,  2 . Cu zgomotul alb se
pot construi multe modele de serii de timp.

Exemplu : Seria de timp Z t  unde Z t  U t    U t 1 ,   0 şi U t  ~ WN 0, 2 
este numită medie mobilă de ordinul întâi (ordin unu). Se notează Z t  ~ MA1 .
Această serie de timp este staţionară pentru orice  , are media 0, funcţia de
 
 1  2  2 , k  0

autocovarianţă  k       2 , k  1 şi funcţia autocorelaţie
0, in rest

1, k 0
 

 k    2
, k  1
 1
0, in rest
1
Evident  1  . Procesul MA(1) este cel mai simplu exemplu de filtru liniar.
2

13
4. Mersul aleator (random walk)
Se consideră X t  un proces discret pur aleator (adică t Z şi variabilele aleatoare
X t sunt independente şi identic repartizate) cu media m şi dispersia  X2 . Procesul
Z t  unde Z t  Z t 1  X t se numeşte mers aleator. În mod obişnuit procesul este
t
pornit de la zero când t  0 , astfel că Z 1  X 1 şi Z t   X i . Avem :
i 1
t t t t
E Z t    E  X i    m  t  m şi Var Z t   Var  X i     X2  t   X2
i 1 i 1 i 1 i 1

Observaţie : Cum media şi dispersia depind de t, mersul aleator este nestaţionar.


Totuşi, este interesant că diferenţele de ordinul întâi ale mersului aleator dau un
proces pur aleator care este staţionar, deci X t  unde X t  Z t  Z t 1 este staţionar.
Cele mai cunoscute exemple de serii de timp care se comportă foarte mult ca mersul
aleator (la întâmplare) sunt preţurile acţiunilor (share prices). În acest caz un model
care corespunde datelor este : Preţul acţiunii în ziua t = preţul acţiunii în ziua (t-1) +
o eroare aleatoare.

5. Procese medie mobilă


Se consideră Z t  un zgomot alb (sau, mai restrictiv, un proces pur aleator, pentru că
în locul necorelării se consideră independenţa) cu media zero şi dispersia  Z2 .
Procesul X t  , unde X t   0  Z t  1  Z t 1     q  Z t  q 5.1 ,
 0  0,  q  0,  i -urile sunt constante, se numeşte proces medie mobilă de ordin q
(abreviat MA(q)).În mod uzual Z-urile sunt scalate, astfel că  0  1 . Plasându-ne în
ipoteza mai restrictivă ( Z t -urile independente), obţinem : EX t   0 şi
q
Var  X t    Z2    i2 . Avem :  k   Cov  X t , X t k  
i 0

Cov 0  Z t   1  Z t 1     q  Z t q ,  0  Z t  k   1  Z t  k 1     q  Z t  k  q  
0, k q
 qk
 Z2    i   i  k , k  0,1,  , q
 i 0
 qk
 2     ,
 Z  i ik k  1,2, , q
i 0

0, k  q
Cum  k  nu depinde de t şi media este constantă, rezultă că procesul X t  este slab
staţionar (altfel zis, staţionar de ordinul doi) pentru toate valorile lui  i  . Mai mult,

14
când Z t -urile sunt repartizate normal, atunci şi X t -urile sunt repartizate normal.
Deci, procesul este complet determinat de medie şi funcţia autocovarianţă. Funcţia de
autocorelaţie a procesului MA(q) este




1, k 0

 k   0, k  q sau k  q
 q k

 
i 0
i  i k
 q
k  1, 2,  , q
  i
2
 i 0

În particular, procesul MA(1) cu 0  1 are funcţia autocorelaţie


1 pentru k  0

 
 k    1 2 , k  1
1   1
0 in rest
Să menţionăm că funcţia autocorelaţie taie (întrerupe) la lag-ul q, ceea ce constituie o
trăsătură a proceselor MA. Privitor la condiţiile ca un MA proces să fie staţionar vom
face următoarele consideraţii. Fie următoarele procese MA de ordinul întâi :
1). X t  Z t    Z t 1
1
2). Xt   Z t 1

1, k 0
 

Primul proces are funcţia autocorelaţie 1 k    2
, k  1
1  
0, in rest
1, k 0

 1
  
Al doilea proces are funcţia autocorelaţie  2 k    2
 , k  1
1   1  1  2
   

0 in rest
Aşadar, avem  1   2 . Astfel se vede că un MA proces nu poate fi identificat după
funcţia autocorelaţie.

15
Punând în cele două modele Z t în termeni de X t , X t 1 ,  , prin substituiri succesive
obţinem :

A). Z t  X t    Z t 1  X t     X t 1    Z t  2   
 X t    X t 1   2  X t  2   3  X t 3  
B).
1 1  1  1 1
Zt  X t   Z t 1  X t    X t 1   Z t  2     X t   X t 1  2  X t 2  
      
Dacă   1 , atunci seria de la A este convergentă iar seria de la B este divergentă.
Astfel, o procedură de estimare care implică estimarea reziduurilor, duce în mod
natural la modelul A, care se zice că este invertibil (în acest caz modelul B nu este
invertibil). Condiţia de invertibilitate ne asigură unicitatea procesului MA pentru o
funcţie autocorelaţie dată. Această condiţie pentru un proces MA de ordin general este
exprimată cel mai bine folosind operatorul de schimbare (mutare, dare) înapoi, notat
cu B, care este definit prin B j X t  X t  j  j . Astfel, ecuaţia (5.1) se va scrie
 
X t   0   1 B   2 B 2     q B q  Z t   B   Z t , unde  B  este un polinom
de ordin q în B. Un MA proces de ordin q este invertibil dacă toate rădăcinile ecuaţiei
 B    0   1 B   2 B 2     q B q  0 5.2  se află în afara cercului unitate.
De notat că în ecuaţia (5.2) B este văzut ca o variabilă complexă şi nu ca un operator.
De asemenea, se poate adăuga în (5.1) o constantă arbitrară m în membrul drept, ceea
ce dă un proces de medie m. Cum aceasta nu schimbă funcţia autocorelaţie pentru
simplificare va fi omisă.
Privitor la formalizarea matematică, se numeşte proces medie mobilă finită procesul
M
stocastic X t ; t  Z}, unde X t   j  Z t  j , M  N,  j  R,  M  0,  M  0 şi
j  M

 
Z t -urile sunt variabile aleatoare necorelate 0,  2 , adică E Z t   0 şi Var Z t    2
(mai restrictiv, sunt considerate independente). Procesul medie mobilă infinită X t 

este dat de reprezentarea X t  
j  
j  Z t  j , unde nu există un număr natural M astfel

q
încât  j  0,  j  Z cu j  M . Procesul definit de X t    j  Z t  j , unde
j 0

 0  0 şi  q  0 se numeşte proces medie mobilă cu o latură de ordin q (mai precis


este un proces medie mobilă stânga de ordin q, pe scurt proces medie mobilă de ordin
q). Aceasta pentru că punând  t  Z tq şi  i   iq avem
q 2q 2q
Xt  
j q
j  Z t  j 
i j q

i0
i q  Z t i  q    i   t i , deci nu se pierde din generalitate
i 0

16
dacă se consideră numai reprezentarea cu o latură.
Un proces medie mobilă de ordin infinit cu media nenulă  , dat de

X t      i  Z t i este numit proces liniar general (aceasta pentru că procesele de
i 0

acest tip se obţin trecând un proces pur aleator printr-un sistem liniar.
Câteva cuvinte despre sistemele liniare. Să considerăm că sunt date observaţii
(înregistrări) asupra intrărilor (inputurilor) şi ieşirilor (outputurilor) unui sistem,
notate în cazul în care timpul este discret cu xt , y t  şi cu xt , y t  în cazul
timpului continuu.
Definiţie. Fie y1 t , y 2 t  ieşirile corespunzătoare intrărilor x1 t , x 2 t . Sistemul se
numeşte sistem liniar dacă şi numai dacă orice combinaţie liniară de intrări (să zicem
1  x1 t    2  x 2 t  ) produce aceeaşi combinaţie liniară de ieşiri, adică
1  y1 t    2  y 2 t  , 1 ,  2 fiind constante.
Definiţie. Dacă intrarea xt  produce ieşirea y t  , atunci sistemul se zice că este
invariant în timp dacă o întârziere de timp  la intrare produce aceeaşi întârziere la
ieşire, adică xt    produce ieşirea y t    , altfel zis relaţia intrare-ieşire nu se
schimbă cu timpul.

a) Sisteme liniare în timp



Un sistem liniar invariant în timp se poate scrie sub forma y t  h
k  
k  xt  k pentru


cazul timpului discret, sau sub forma y t    hu   xt  u du pentru cazul timpului


continuu. Funcţia de ponderare hu  (pentru timpul continuu) sau hk  (pentru timpul
discret) arată o caracterizare (descriere) a sistemului în timp şi este cunoscută sub
numele de FIR (Funcţia Impuls Răspuns). Un exemplu foarte simplu de sistem liniar
este dat de „întârzierea simplă”, adică y t  xt  d unde întregul d arată timpul de
1 pentru k  d
întârziere. Funcţia sa FIR este :
hk  
0 in rest
Alt exemplu de sistem liniar este „câştigul pur”, adică y t  c  xt unde constanta c
c pentru k  0
reprezintă câştigul. FIR –ul acestui sistem este : hk  
0 in rest

b). Sisteme liniare în frecvenţă

O altă cale de descriere a unui sistem liniar este prin intermediul unei funcţii

17
denumită funcţia de transfer (FRF – Funcţia Răspuns Frecvenţă). Aceasta este

transformata Fourier a funcţiei FIR, adică este H     hu   e
 i u
du,   0 în


cazul timpului continuu şi este H     hk  e  i k , 0  .


k

Întrun sistem liniar o intrare exponenţială complexă xt   e i t  cos t  i  sin t dă
o ieşire y t   H    xt  . Pentru sistemul liniar „întârzierea simplă”, y t   xt   
unde  este o constantă, funcţia FIR este hu    u    unde  este funcţia delta

0, t0
Dirac, adică  t   
 t0
, astfel încât   t dt  1

(altfel zis, pentru orice

funcţie  t  care este continuă în t  0 , funcţia delta Dirac este funcţia  care

verifică

  t   t dt  0 . Funcţia de transfer este dată de


H      u     e i u du  e i  .


6. Procese autoregresive

Dacă Z t  este un proces pur aleator cu media 0 şi dispersia  Z2 , atunci un proces


X t  se zice că este proces autoregresiv de ordin p dacă
X t   1  X t 1   2  X t  2     p  X t  p  Z t (6.1)
Acest model seamănă cu modelul regresiei multiple, dar diferenţa constă în faptul că
X t nu este regresat peste variabile independente ci peste valorile din trecut. Se
utilizează abrevierea AR(p) proces.
Procese de ordinul întâi : p 1 şi X t    X t 1  Z t (6.2)
Prin substituţii succesive obţinem :
X t    X t 1  Z t      X t  2  Z t 1   Z t    Z t    Z t 1   2  Z t  2  
pentru  1    1 . Deci X t  poate fi exprimat ca un proces medie mobilă de ordin
infinit. Utilizând operatorul de mutare înapoi (întoarcere) B, ecuaţia (6.2) se scrie
1  B   X t  Z t , astfel că
1

X t  1  B   Z t  1  B   2 B 2    Z t  
Z t    Z t 1   2  Z t 2  

Rezultă : E  X t   0 şi Var  X t    Z2  1   2   4   
 Z2
Astfel, dispersia este finită dacă   1 , caz în care avem : Var  X t     X2
1 2

18
Funcţia autocovarianţă este :
    
 k   E  X t  X t  k   E    i  Z t i      j  Z t  k  j    Z2    i   k  i pt. k  0
 i   j  i 0

2
Aceasta converge în cazul   1 la  k    k  Z 2   k   X2
1
Pentru k  0 găsim  k     k  .
Deoarece  k  nu depinde de t, un proces AR(1) este slab staţionar dacă   1 .
 k   k   X2
Funcţia autocorelaţie este :  k      k , k  0,1,2, 
 0  X2
Pentru toţi întregii k avem  k    k , k  0,1,2, 
Mai simplu, funcţia autocorelaţie poate fi găsită presupunând apriori că procesul este
staţionar, în care caz E  X t   0 . Înmulţind ecuaţia (6.2) cu X t  k şi luând media
obţinem : pentru k  0 :   k       k  1 presupunând că E Z t  Z t k   0
Deoarece  k  este o funcţie pară, trebuie să avem  k      k  1 pentru k  0.

7. Procese mixate ARMA(p,q)

Sunt procese X t  autoregresive de ordin p cu reziduuri medie mobilă de ordin q care


verifică relaţia X t  1  X t 1     p  X t  p  Z t  1  Z t 1     q  Z t  q , unde
Z t -urile sunt reziduuri medie mobilă de ordin q.

8. Procese nestaţionare autoregresive şi de medie mobilă ARIMA(p,n,q)


Sunt procese nestaţionare care în forma originală prezintă tendinţă şi prin diferenţe
de ordin n pot fi aduse la forma staţionară, p fiind ordinul părţii autoregresive şi q
ordinul părţii medie mobilă a modelului.
Pentru ARIMA(1,1,2) ecuaţia este :
y t   0   1  y t 1  y  Z t   1  Z t 1   2  Z t  2

9. Modelul ARFIMA (AutoregressiveFractionallyIntegratedMovieAverage)


Este o variantă a modelului ARIMA(p,d,q) în care d este ordinul diferenţei şi este o
fracţiune din 1 (0<d<1). Folosind operatorul de diferenţiere înapoi (trimitere în trecut)
B avem : 1  B d  yt  z t , z t ~ N 0,  z2 , 0  d  1, unde

1  B d  1  d  B  d  d  1  B 2  d  d  1  d  2  B 3  
2! 3!
d
Astfel, forma generală a lui ARFIMA este 1  B   B  y t   B z t , unde  ,  , B au
semnificaţiile :  B  y t  z t (modelul AR(p), adică

19
y t   0  1  y t 1     p  y t  p  z t )
y t   B   z t (modelul MA(q), adică y t  y  zt  1  z t 1     q  z t  q )

10. Seria integrată


Seria integrată este seria de timp nestaţionară care prin diferenţele de ordinul întâi
sau doi (adică y t  y t  yt 1 ,  2 y t  y t  y t 1 ) poate fi transformată în serie
staţionară.

11. Serii cointegrate


Sunt seriile cronologice care fiind integrate de acelaşi ordin admit o combinaţie
liniară care este staţionară (integrată de ordin zero) sau este integrată de ordin mai
mic decât ordinul de integrare a seriilor iniţiale.
Exemplu. Seriile xt , y t  au acelaşi ordin de integrare şi există z t  , unde
z t  y t  a  b  xt  care este staţionară.

12. Procese ARCH (Autoregressive Conditional Heteroskedasticity)


Prind împrăştierile inegale (eteroschedasticitate) ale valorilor reziduale în timp
(adică o dependenţă sub forma autocorelaţiei şi pentru variabilele reziduale). F.R.
Engle a propus ca dispersia erorii să fie dependentă de valorile y t 1 sau z t 1 . Astfel
avem :  z2t   0   1  y t21 sau varianta  z2t   0   1  z t21     p  z t2 p .
Spre deosebire de modelul AR în care eroarea z t este considerată aleatoare,
repartizată normal şi cu dispersia constantă, iar E  y t y t 1   a  y t 1 (media
condiţionată este dependentă de timp), în versiunea lui Engle dispersia erorii este
dependentă de timp (de aici iniţialele CH adăugate lui AR). O variantă simplă a
 
modelului este : y t  a  y t 1  b  xt  z t , unde z t ~ N 0,  z2t ,  z2t   0   1  z t21

O limitare importantă a modelelor ARMA este dată de faptul că tratează prea rigid
varianţa condiţionată a lui X t  k . Clasa proceselor ARMA cu heteroscedasticitate
condiţional autoregresivă sau ARMA-ARCH procese permite varianţei condiţionate a
lui X t să depindă de istoria procesului. O serie de timp cu media zero, X t , este un
proces pur ARCH(1) dacă X t   t  Yt , Yt  ~ IID0, 1 , (se scrie X t ~ARCH(1)),
unde  t (volatilitatea stocastică) este un element al procesului stocastic care verifică
relaţia  t2   2    X t21 , cu 0 şi   0. Deoarece
 
E X t2 S t 1   t2   2    X t21 , un proces ARCH(1) pentru X t corespunde unui
proces AR(1) pentru X t2 . Dacă 0    1 , atunci procesul ARCH(1) este staţionar şi

20
2 2
varianţa sa necondiţionată este   . Diferenţa dintre varianţa condiţionată şi
1
2

necondiţionată este  t2      X t21   . Avem 2

   E   X   S        
2 2 2
E X t21 S t 1   t
2
t 1 t
2


Repetând această formula obţinem E X t2 k S t 1      k 1  X t21   , k  1,2, 
2 2

Astfel, E X t2 k S t 1  k
2
  .


O generalizare simplă a procesului pur ARCH 1 este procesul pur ARCH m  , unde
 t2   2   1  X t21     m  X t2m cu  j  0, j  1, m  1, şi  m  0, care
corespunde unui proces AR m  pentru X t2 .
Definiţie. O serie de timp X t  este numită proces ARMA p, q   ARCH m  dacă
satisface relaţia Φ B  X t  Θ B Yt , Yt  ~ ARCH m  unde  B  şi  B  sunt
polinoame în lag- operatorul de ordin p şi, respectiv q.
Mai general este un proces având heteroscedasticitate generalizată condiţional
autoregresivă (GARCH) de ordin r, m  , generalizarea lui Bollerslev, unde
 t2   2   1   t21     r   t2 r   1  X t21     m  X t2m , cu
 r , m  0,  i  0, i  1, r  1,  j  0, j  1, m  1 . Avem ARCH m   GARCH 0, m  .
Notând Vt  X t2   t2 , atunci un proces GARCH r, m  poate fi scris
X t2     1  X t21     p  X t2 p   1  Vt 1     r  Vt  r unde
p  maxm, r ,  j   j   j ,  j  0 for j  m şi  j  0 pentru j  r. Deci un
proces GARCH r , m  pentru X t corespunde unui proces ARMA p, r  pentru X t2 .
Definiţie. O serie de timp X t  este numită proces ARMA p, q   GARCH r , m  dacă
satisface relaţia Φ B  X t  Θ B Yt , Yt  ~ GARCH r , m  .

Pentru exemplificarea noţiunilor legate de modelele autoregresive, am făcut


inferenţă statistică pentru determinarea coeficienţilor prin metoda celor mai mici
pătrate pe datele din rapoartele anuale ale Comisiei de Supraveghere a Asigurărilor şi
~
apoi am efectuat predicţiile 
Xˆ      X , X      X    X
t t 1 t , t 1 t 2 
valorilor de interes în două cazuri : întâi predicţia pas cu pas (adică datele din anul
anterior sau din anii anteriori sunt cele raportate de CSA), apoi predicţia pe termen
lung (caz în care, în predicţie, se folosesc predicţiile anterioare şi nu datele raportate,
deci ar fi cazul elaborării unor prognoze pe termen lung).

21
Tabel. 1. Valoarea totală a primelor de asigurare brute încasate din asigurări directe:

An Prime totale încasate Prime încasate în Prime încasate


(lei noi) asigurările de viaţă asig. generale

1997 130402200 8073900 122328300


1998 241484000 19944700 221539300
1999 427393000 50569000 376824000
2000 673887300 106658600 567228700
2001 1001242500 211473300 789769200
2002 1645965600 414514000 1231451600
2003 2422508810.2 579003012 1843505798.2
2004 3216393971.5 693443836.2 2522950135.3
Sursa : Rapoartele Anuale ale CSA

Tabelul 2. Predicţii pentru primele brute încasate din asigurările directe

Prime brute încasate* Predicţii pas cu pas X̂ t Predicţii pe termen


Anul (Xt) ˆ
lung Xˆ t

1997 130,402,200 --- ---

1998 241,484,000 311,729,066.9 311,729,066.9

1999 427,393,000 458,654,611.1 551,566,273.3

2000 673,887,300 704,552,507.8 868,793,866.4

2001 1,001,242,500 1,030,585,298 1,288,384,085

2002 1,645,965,600 1,463,571,087 1,843,367,180

2003 2,422,508,810.2 2,316,332,676 2,577,431,565

2004 3,216,393,971.5 3,343,449,933 3,548,362,980

2005 4,384,987,227** 4,393,505,021 4,832,593,399


*
Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise.

22
Eroarea relativă pentru predicţiile din 2005 este de 0.2% în cazul pas cu pas şi de
2.7% pe termen lung. Pentru predicţia îndemnizaţiilor brute plătite de asigurători
pentru asigurările directe generale şi de viaţă, atât cumulate cât şi separate, am folosit
două modele lineare.

Tabelul 2’. Situaţia pe date deflatate

Prime brute încasate Predicţii Predicţii


Anul deflatate (Xt) ~
X̂ t Xt

1997 130,402,200 --- ---

1998 171,752,489.3 157,729,471.75 ---

1999 196,368,185.8 210,083,500.22 203,946,382.41

2000 220,057,866.1 241,249,687.82 236,706,333.31

2001 250,925,319.5 271,243,436.77 267,667,960.66

2002 350,171,401 310,325,038.33 307,698,100.38

2003 451,689,130.8 435,981,527.41 434,715,398.98

2004 548,685,334.6 564,514,173.86 567,163,062.07

2005 688,799,178.4 687,322,069.45 693,961,104.10

Eroarea relativă pentru predicţia din 2005 este de 0,2% la modelul de ordinul întâi şi
de 0,75% la modelul de ordin doi, iar eroarea relativă totală a predicţiilor este de 2%
la ambele modele. Predicţia pentru 2006 este de 875,273,474.23 pentru date deflatate
(5,990,015,464 lei).

Tabelul 3. Predicţii pentru îndemnizaţiile (despăgubirile) brute plătite

Anul Îndemnizaţii * Predicţii pas cu pas Predicţii pas cu pas

(Xt) ~
X̂ t Xt

1997 69,925,100 --- ---

1998 102,212,700 114,022,130.901 ----

23
1999 189,589,900 161,229,924.099 193,403,696.19

2000 248,978,900 288,984,380.539 273,600,712.37

2001 406,293,900 375,817,208.937 420,965,932.04

2002 649,832,600 605,827,924.718 567,138,913.81

2003 842,267,901 961,906,561.258 886,204,782.46

2004 1,311,879,000 1,243,266,770.548 1,307,528,164.13

2005 1,758,745,510 1.929,886,514.498 1,765,377,520.80


*
Sursa : Rapoartele Anuale ale CSA.

Eroarea relativă a predicţie X̂ t pentru anul 2005 este de 9.7%. Definind eroarea

 Xˆ 2
t  Xt
t
relativă totală (ERT) a predicţiilor X̂ t ca ERT  , rezultă că ERT
X
t
t

~
este egală cu 4.2%. Eroarea relativă a predicţiei X t pentru anul 2005 este egală cu
1.8%.
Folosind modelul autoregresiv linear de ordinul întâi pentru primele brute încasate în
contractele directe de asigurări generale (non-life) am obţinut
X t  103034505.55  1.31273  X t 1 cu care am făcut predicţiile din tabelul 4.

Tabelul 4. Predicţii pentru primele brute încasate din asigurările generale directe

Anul Prime brute Predicţii pas cu pas Predicţii pe date

încasate* (Xt) X̂ t deflatate

1997 122,328,300 --- ----

1998 221,539,300 263,618,589.2 141,284,469.84

1999 376,824,000 393,855,889.4 186,451,070.54

2000 567,228,700 597,702,842.7 206,403,634.37

2001 789,769,200 847,652,889.3 221,905,572.13

24
2002 1,231,451,600 1,139,788,578.9 238,181,828.83

2003 1,843,505,798.2 1,719,598,512.4 320,287,350.82

2004 2,522,950,135.3 2,523,060,692.3 425,063,112.95

2005 3,346,997,220** 3,414,987,959.3 536,137,273.30***


*
Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise, ***3,413,121,224.82 lei.

Eroarea relativă pentru predicţia din anul 2005 este de 2,03%, iar eroarea relativă
totală a predicţiilor este de 1,709%. Predicţia pentru volumul primelor brute încasate
din asigurările generale directe în 2006 este de 4,496,739,655.42 lei. În cazul datelor
deflatate, eroarea relativă a predicţiei pentru 2005 este de 1,975%, iar eroarea relativă
totală a predicţiilor este de 2,291%.
În cazul asigurărilor de viaţă modelul obţinut este
X t  59577744.34  1.193007  X t 1 , iar pentru date deflatate este
Xˆ t  12430011.13244  1.07045  X t 1 .

Tabelul 5. Predicţii pentru primele brute încasate din asigurările de viaţă directe

Anul Prime brute Predicţii pas cu pas Predicţii pe date

încasate* (Xt) X̂ t deflatate

1997 8,073,900 --- ----

1998 19,944,700 69,209,965.58 21,072,716.00

1999 50,569,000 83,371,916.04 27,614,791.13

2000 106,658,600 119,906,927.96 37,301,077.42

2001 211,473,300 186,822,227.40 49,713,089.73

2002 414,514,000 311,866,924.39 69,161,879.41

2003 579,003,012 554,095,951.49 106,828,585.53

2004 693,443,836.2 750,332,535.32 127,993,713.31

2005 1,037,990,007** 886,861,268.27 139,058,586.40***


*
Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise, ***885,265,455.84 lei.

25
Eroarea relativă totală a predicţiilor este de 6,54%, eroarea predicţiei pentru 2005
este de 14,5% (mare, deci modelul linear de ordinul 1 nu e recomandabil pentru
prognoze aici), iar predicţia pentru 2006 este de 1,297,907,347.92 lei. În cazul datelor
deflatate eroarea relativă a predicţiei pe 2005 este de 14,7%, iar eroarea relativă totală
a predicţiilor este de 5,54%.

Folosind modelul autoregresiv linear de ordinul doi pentru primele brute încasate în
contractele directe de asigurări generale (non-life) am obţinut
X t  88208606.32  1.124101  X t 1  0.346886  X t  2 cu care am făcut predicţiile din
tabelul 6.

Tabelul 6. Predicţii pentru primele brute încasate din asigurările generale directe

Anul Prime brute ~


Predicţii X t
încasate* (Xt)

1997 122,328,300 ---

1998 221,539,300 ---

1999 376,824,000 379,675,001.99

2000 567,228,700 588,645,501.15

2001 789,769,200 856,545,575.45

2002 1,231,451,600 1,172,752,146.19

2003 1,843,505,798.2 1,746,443,710.78

2004 2,522,950,135.3 2,587,667,497.91

2005 3,346,997,220** 3,563,744,112.26

Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise.

Eroarea relativă pentru predicţia din anul 2005 este de 6,4%, iar eroarea relativă
totală a predicţiilor este de 2,45%. Predicţia pentru volumul primelor brute încasate în
asigurările generale directe este de 4,725,745,436.68 RON.
Folosind modelul autoregresiv linear de ordinul doi pentru îndemnizaţiile brute şi
valorile de răscumpărare plătite în contractele directe de asigurări de viaţă am obţinut
X t  41,593,144.816  0.371383  X t 1  0.010592  X t  2 cu care am făcut predicţiile
din tabelul 7.

26
Tabelul 7. Predicţii pentru îndemnizaţiile brute şi răscumpărările plătite
în asigurările de viaţă directe

Îndemnizaţii brute Predicţii


Anul ~
Plătite* (Xt) Xt

1997 1,858,700 ---

1998 4,082,800 ---

1999 12,053,200 43,129,113.47

2000 8,343,700 46,112,740.37

2001 57,633,200 44,819,515.05

2002 142,947,200 63,085,501.75

2003 62,499,098 95,291,716.14

2004 75,280,471 66,318,282.14

2005 97,385,521 70,212,989.45


*
Sursa : Rapoartele Anuale ale CSA

Eroarea relativă pentru predicţia din anul 2005 este de 27,9% (mare !), iar eroarea
relativă totală a predicţiilor este de 22,81%. Predicţia pentru volumul îndemnizaţiilor
brute plătite în asigurările de viaţă directe este de 78,557,801.97 RON. Evident,
erorile mari arată neadecvarea modelului pentru prognoze. Această evoluţie prea
sinuoasă a acestor sume se explică în parte şi prin influenţa schimbărilor din
legislaţie, care au reîncadrat anumite produse la altă categorie de asigurări, şi prin
faptul că evoluţia asigurărilor de viaţă a înregistrat explozii şi prăbuşiri.

27
CAPITOLUL 2 - PROIECTARE ŞI IMPLEMENTARE

În acest capitol este prezentată transpunerea formulelor matematice într-un mod mai
plăcut utilizatorului, persoanei care doreşte să analizeze datele prin metodele
implementate.

Astfel, în capitolul 2 sunt prezentate ideile, şabloanele, modalităţile care au condus la


transformarea unor date abstracte - numerele, în lucruri vizibile, palpabile – grafice,
imagini care pot fi imprimate.

2.1 Proiectare

Înainte de implementarea claselor se analizează cerinţele aplicaţiei şi se fac


grafice pentru evidenţierea cazurilor de utilizare şi observarea relaţiilor dintre clase –
pentru a uşura activitatea de implementare.

Figură 2.1-1

28
Astfel, în acest proiect se doreşte existenţa doar a unei singure categorii de
utilizatori. Acest poate fi atât client cât şi administrator. Utilizatorul va avea
posibilitatea de a vizualiza datele sub forma unui grafic, îl va putea printa şi va putea
alege oricând un nou set de date. De asemenea utilizatorul va putea adăuga noi funcţii
sau moduri de afişare a graficelor din program prin opţiunea de actualizare.

Etapele pe care le urmează un utilizator pentru vizualiza datele sub forma unui
grafic sunt oferite de diagramele de mai jos (Figură 2.1-2 şi Figură 2.1-3).

Figură 2.1-2

29
Figură 2.1-3

Un utilizator rulează programul şi accesează meniul File, submeniulUpdate


(Figură 3.1.1-2). În această stare el poate să aleagă fişierele pe care doreşte să le
importe în aplicaţie. În momentul în care doreşte să importe o nouă metodă de analiză
şi afişare a datelor va trebui să bifeze checkbox-ul de lângă butonul Update.(Figură
3.1.5-2).

Notă: Ultima dată se importă fişierele care conţin metodele apelate din
interfaţă ce vor analiza şi afişa datele.

Apăsarea butonului Browse va deschide o fereastră care permite selectarea


fişierului ce va fi importat (Figură 3.1.6-1).

După selectarea fişierului şi apăsarea butonului Load File se va reafişa


fereastra Upload. Această iteraţie se va repeat pentru fiecare fişier care trebuie
importat.

Fişierele vor fi importate în momentul ieşirii din program. Pentru a se folosi


noua (noile) metodă(e) va trebui repornită aplicaţia deoarece în procesul de update
executabilul aplicaţiei, fişierul .jar se va suprascrie, iar Java – şi în general orice
fişier care rulează la un momentdat, nu se poate suprascrie în timpul execuţiei. El
trebuie obligatoriu să fie închis/oprit pentru această operaţie.

30
Întreg acest flux este descris în graficele de mai jos.

Figură 2.1-4

Pentru cazul de utilizare din Figură 2.1-4 diagrama stărilor este prezentată mai
jos (Figură 2.1-5 şi Figură 2.1.6). Actualizarea programului necesită restartarea
acestuia deoarece copierea şi compilarea claselor se fac cu procese Windows care
sunt externe proceselor Java.

În urma procesului de actualizare fişierul .jar, care reprezintă executabilul


acestui program, se suprascrie, de aici şi nevoia de executare a proceselor de copiere
externe Java şi executarea lor atunci când programul nu rulează.

31
Figură 2.1-5

Întreg fluxul de update al aplicaţiei poate fi redat prin diagrama de mai jos-
Figură 2.1-6.

Figură 2.1-6

32
2.2 Şabloane de proiectare
Definiţie

Toate sistemele orientate pe obiecte (OO) bine structurate abundă în şabloane


(patterns), mergând de la mecanisme care conturează forma sistemului în ansamblu,
până la şabloane locale (cum ar fi de exemplu modul de tratare a excepţiilor).

Un şablon reprezintă o soluţie comună a unei probleme într-un anumit context.

Importanţa şabloanelor (standardelor) în construirea sistemelor complexe a


fost de mult recunoscută în alte discipline. În cadrul comunităţii proiectanţilor de
software OO ideea de a aplica şabloane se pare că a fost inspirată de propunerea unui
arhitect, Christopher Alexander, care a lansat iniţiativa folosirii unui limbaj bazat pe
şabloane pentru proiectarea clădirilor şi a oraşelor. Acesta afirma că: "Fiecare şablon
descrie o problemă care apare mereu în domeniul nostru de activitate şi indică esenţa
soluţiei acelei probleme, întrun mod care permite utilizarea soluţiei de nenumărate ori
în contexte diferite". Deşi în domeniul sistemelor OO soluţiile sunt exprimate în
termeni de obiecte şi interfeţe (în loc de ziduri, uşi, grinzi etc), esenţa noţiunii de
şablon este aceeaşi, adică de soluţie a unei probleme întrun context dat. [6]

Clasificare

Şabloanele utilizate în sistemele OO pot fi clasificate într-o ierarhie, după cum


urmează:

 idiomuri

 mecanisme

 cadre (frameworks).

Un idiom este legat de un anumit limbaj de programare şi reprezintă o


convenţie general acceptată de utilizare a limbajului respectiv.
Importanţa acestui idiom constă în faptul că el reprezintă un anumit stil acceptat de
comunitatea "vorbitorilor" de C şi orice programator care citeşte o secvenţă C
recunoaşte imediat această convenţie. Violarea acestui idiom are drept consecinţă
producerea de cod greu de înţeles, chiar dacă este corect.

Practic, fiecare limbaj de programare îşi are propriile sale idiomuri.


Se poate spune că un idiom este o formă de reutilizare pe scară mică. [6]

Un mecanism este o structură în cadrul căreia obiectele colaborează în


vederea obţinerii unui anumit comportament care satisface o anumită cerinţă a

33
problemei. Mecanismele reprezintă decizii de proiectare privind modul în care
cooperează colecţiile de obiecte. Ele se mai numesc şabloane de proiectare (design
patterns). Majoritatea sistemelor OO includ mecanisme referitoare la:

 persistenţa obiectelor

 controlul stocării

 controlul proceselor

 transmisia/recepţia mesajelor

 distribuirea şi migrarea obiectelor

 conectarea în reţele (networking)

 tranzacţii

 evenimente

 modul de prezentare ("look & feel") al aplicaţiei.

Un cadru reprezintă o colecţie de clase care oferă un set de servicii pentru un


domeniu particular. Cadrul exportă un număr de clase şi mecanisme pe care
utilizatorii le pot adapta. Cadrele sunt forme de reutilizare pe scară largă. Cele mai
răspândite tipuri de cadre sunt cele destinate creării de interfeţe grafice.

Proiectarea sistemelor OO este o activitate dificilă, iar proiectarea sistemelor


OO reutilizabile este încă şi mai grea. Soluţia trebuie să fie specifică problemei, dar
totodată suficient de generală.

Un proiectant fără experienţă este de multe ori copleşit de multitudinea


opţiunilor disponibile şi are tendinţa de a se întoarce la tehnicile non-obiectuale pe
care le-a folosit în trecut. Un proiectant experimentat ştie că nu trebuie să rezolve
fiecare problemă începând de la zero, ci reutilizând soluţii din proiecte anterioare.
Atunci când descoperă o soluţie bună o va folosi mereu. Acest tip de experienţă este o
parte din ceea ce conferă unui proiectant statutul de expert.

Elementele de bază ale unui şablon de proiectare:

 numele şablonului: descrie sintetic problema rezolvată de şablon şi


soluţia;

 problema: o descriere mai largă a problemei rezolvate şi a contextului


în care ea apare;

34
 soluţia: o descriere a elementelor de proiectare utilizate şi a relaţiilor
dintre ele. Soluţia nu descrie un proiect particular sau o implementare concretă, ci un
ansamblu abstract de clase şi obiecte care rezolvă un anumit gen de probleme de
proiectare;

 consecinţele şi compromisurile implicate de folosirea şablonului:


acestea pot privi impactul asupra flexibilităţii, extensibilităţii sau portabilităţii
sistemului, după cum pot să se refere la aspecte ale implementării sau limbajului de
programare utilizat. Compromisurile sunt de cele mai multe ori legate de spaţiu şi
timp.

Deoarece există multe şabloane de proiectare, este necesară o anumită


clasificare a lor, în vederea alcătuirii unui catalog cu ele.

Criterii de clasificare:

- scop: şabloanele pot fi, din acest punct de vedere: creaţionale,


structurale sau comportamentale.

 Şabloanele creaţionale (creational patterns) privesc modul de creare a


obiectelor.

 Şabloanele structurale (structural patterns) se referă la compoziţia claselor


sau a obiectelor.

 Şabloanele comportamentale (behavioral patterns) caracterizează modul în


care obiectele şi clasele interactionează şi îşi distribuie responsabilităţile.

- domeniu de aplicare: şabloanele se pot aplica obiectelor sau claselor.

 Şabloanele obiectelor se referă la relaţiile dintre obiecte, relaţii care au un


caracter dinamic.

 Şabloanele creaţionale ale obiectelor acoperă situaţiile în care o parte din


procesul creării unui obiect cade in sarcina unui alt obiect.

 Şabloanele structurale ale obiectelor descriu căile prin care se asamblează


obiecte.

 Şabloanele comportamentale ale obiectelor descriu modul în care un grup de


obiecte cooperează pentru a îndeplini o sarcină ce nu ar putea fi efectuată de
un singur obiect.

 Şabloanele claselor se referă la relaţii dintre clase, relaţii stabilite prin


moştenire şi care sunt statice (fixate la compilare).

35
 Şabloanele creaţionale ale claselor acoperă situaţiile în care o parte din
procesul creării unui obiect cade in sarcina subclaselor.

 Şabloanele structurale ale claselor descriu modul de utilizare a moştenirii în


scopul compunerii claselor.

 Şabloanele comportamentale ale claselor utilizează moştenirea pentru


descrierea unor algoritmi şi fluxuri de control.

Şabloanele de proiectare rezolvă multe din problemele zilnice cu care se


confruntă proiectanţii. Câteva din aceste probleme sunt următoarele:

Găsirea obiectelor adecvate

Aşa cum se ştie, un obiect include atât date, cât şi metode (operaţii) care
operează asupra datelor. Obiectul execută o operaţie când primeşte o cerere (mesaj)
de la un client. Mesajele reprezintă singura cale prin care un obiect este determinat să
execute o operaţie, în timp ce operaţiile sunt singurul mod de a modifica datele
interne ale obiectului. Din cauza acestor restricţii starea internă a obiectului se spune
că este încapsulată: ea nu poate fi accesată direct, iar reprezentarea ei este invizibilă
dinspre exteriorul obiectului.

Partea dificilă în proiectarea unui sistem OO este descompunerea sistemului


în obiecte. Aceasta deoarece procesul este influenţat de mai mulţi factori care
acţionează adesea în mod contradictoriu: încapsularea, granularitatea, dependenţele,
flexibilitatea, performanţele, evoluţia, gradul de reutilizare etc.

Multe din obiectele care apar la proiectare provin din modelul creat în faza de
analiză. Dar, pe parcurs, la proiect se vor adăuga şi clase care nu au corespondenţe în
lumea reală. Unele din aceste clase sunt de nivel primar (de ex. tablourile). Altele au
un nivel de abstractizare mai ridicat. Şablonul Composite introduce o abstracţiune
menită să asigure tratarea uniformă a obiectelor care nu au un corespondent fizic.
Modelarea strictă a lumii reale va duce la un sistem care reflectă realitatea curentă,
dar nu neapărat şi pe cea viitoare. Abstracţiunile identificate în timpul proiectării sunt
esenţiale în obţinerea unui sistem flexibil. Şabloanele ne pot ajuta în identificarea
unor abstracţiuni mai puţin evidente şi a obiectelor care le pot reprezenta. De
exemplu, obiectele care reprezintă procese sau algoritmi nu apar în natură, dar ele nu
pot lipsi dintrun proiect. Şablonul Strategy descrie modul de implementare a unor
familii interschimbabile de algoritmi. Şablonul State reprezintă fiecare stare a unei
entităţi sub forma unui obiect. Asemenea obiecte sunt rareori descoperite în timpul
analizei sau chiar a stadiului incipient al proiectării.[6]

36
Determinarea granularităţii obiectelor

Obiectele ce compun un sistem pot varia "îngrozitor" ca mărime şi număr. Ele


pot reprezenta practic orice: de la componente hardware până la aplicaţii întregi. Este
dificil de stabilit unde trebuie să se "oprească" un obiect.
Există şabloane care acoperă şi acest aspect. Astfel, şablonul Facade descrie modul în
care subsistemele complete pot fi reprezentate ca obiecte, iar şablonul Flyweight arată
cum se poate gestiona un număr uriaş de obiecte la nivelele cele mai fine de
granularitate. Alte şabloane descriu căile prin care un obiect poate fi descompus în
obiecte mai mici. Abstract Factory şi Builder reprezintă obiecte a căror unică
responsabilitate este crearea de alte obiecte. Visitor şi Command reprezintă obiecte a
căror unică responsabilitate este implementarea unui mesaj către alt obiect sau grup
de obiecte.[6]

Specificarea interfeţelor obiectelor

Pentru fiecare operaţie declarată întrun obiect se precizează numele, obiectele


pe care le ia ca parametri şi valoarea returnată; aceste elemente formează
semnătura operaţiei. Multimea tuturor semnăturilor corespunzătoare operaţiilor
dintrun obiect reprezintă interfaţa obiectului. Interfaţa unui obiect descrie complet
setul mesajelor care pot fi trimise spre obiectul respectiv.

Un tip este un nume utilizat pentru a referi o anumită interfaţă. Astfel, vom
spune despre un obiect că este de tipul Window dacă el acceptă toate mesajele
corespunzătoare operaţiilor definite în interfaţa numită Window. Ca urmare, un
obiect poate avea mai multe tipuri, adică o parte a interfeţei sale poate fi de un tip, iar
alta parte - de alt tip. De asemenea, mai multe obiecte pot partaja un anumit tip
comun, dacă interfeţele lor includ tipul respectiv. Interfeţele pot să conţină, la rândul
lor, alte interfeţe ca submulţimi. O interfaţă nu dă nici un detaliu relativ la
implementarea unui obiect, iar obiecte distincte pot implementa în mod diferit o
aceeaşi cerere. Sau, altfel spus, două obiecte având implementări complet diferite pot
avea interfeţe identice.[6]

Când o cerere este trimisă unui obiect, operaţia care se va executa depinde de

 cerere

 obiectul care recepţionează cererea.

Specificarea implementării obiectelor

Implementarea unui obiect este definită prin intermediul clasei obiectului.


Clasa unui obiect specifică datele interne ale obiectului şi definiţiile operaţiilor pe
care acesta le poate executa.

37
Obiectele sunt create prin instanţierea unei clase; se mai spune că un obiect este o
instanţă a unei clase. Procesul de instanţiere a unei clase presupune alocarea de
memorie pentru datele interne ale obiectului respectiv şi asocierea operaţiilor cu
aceste date. O clasă poate fi instanţiată de mai multe ori, în felul acesta rezultând mai
multe exemplare similare de obiecte.

Pe baza unor clase existente se pot defini noi clase, folosind moştenirea
claselor. O subclasă moşteneşte de la una sau mai multe clase părinte (superclase)
toate datele şi operaţiile definite în acestea din urmş. Obiectele instanţe ale subclasei:

 vor conţine toate datele definite în subclasă şi în clasele părinte

 vor putea executa toate operaţiile definite în subclasă şi în clasele


părinte.

O clasă abstractă are drept scop principal definirea unei interfeţe comune
pentru subclasele sale. Implementarea operaţiilor unei clase abstracte este "pasată"
parţial sau în întregime subclaselor sale. De aceea, o clasă abstractă nu poate fi
instanţiată. Operaţiile declarate întro clasă abstractă, dar neimplementate se numesc
operaţii abstracte.
Clasele care nu sunt abstracte se numesc clase concrete.

O subclasă poate detalia sau redefini comportamentul claselor părinte. Mai


precis, subclasa poate redefini (override) o operaţie care apare şi întro clasă părinte,
ceea ce permite subclasei să poată prelua cereri în locul superclasei.

O clasă mixin este o clasă care are drept scop oferirea unei interfeţe sau a
unei funcţionalităţi opţionale altor clase. Ea este similară unei clase abstracte, în
sensul că nu poate fi instanţiată, dar nu poate figura singură ca părinte al unor
subclase, ci doar întro schemă de moştenire multiplă.[6]

2.2.1 Şablonul Command


Şablonul Command pune la dispoziţia programatorului o modalitate de
implementare a unei acţiuni pentru un singur obiect şi pentru fiecare situaţie în care
obiectul se află şi execută o acţiune.

Acesta permite clientului să satisfacă cererea venită (să execute o acţiune) fără
a cunoaşte detaliile acţiunii care va fi făcută şi ,de asemenea, permite operarea
oricărui tip de schimbare în ceea ce priveşte răspunsul cererii fără a afecta în niciun
fel programul client.[1]

38
Acest şablon oferă o interfaţă standard pentru manipularea cererilor
utilizatorilor. Fiecare cerere este încapsulată întrun obiect numit comandă. Figura de
mai jos (Figură 2.2.1-1) arată care sunt clasele implicate în şablonul Command.[10]

Figură 1-1
Clasa Command reprezintă încapsularea unui singur comportament. Fiecare
comportament în aplicaţie va fi modelat în funcţie de ceea ce vrem să facă respectiva
comandă: salvare, ştergere, ieşire, colorare etc.

Componenta CommandManager este responsabilă pentru acordarea accesului


la comenzile disponibile din aplicaţie.

Ultima componentă, Invoker, are responsabilitatea executării efective a


comenzii.[10]

Exemplu: Să considerăm un program simplu care ne permite să alegem din


meniu opţiunile File, Open a File şi Exit şi în fereastra de afişare să existe un buton a
cărui acţiune este colorarea ferestrei în roşu(Figură 2.2.1-2).[1]

Figură 1-2

39
Efectuare unui click pe acest buton sau pe butonul de meniu va avea ca efect
declanşarea unui eveniment de tipul actionPerformed având următorul cod:

public void actionPerformed(ActionEvent e) {

Object obj = e.getSource();

if(obj == mnuOpen)

fileOpen(); //deschidere fişier

if (obj == mnuExit)

exitClicked(); //ieşire din program

if (obj == btnRed)

redClicked(); //colorare în roşu

Cele trei comenzi sunt implementate astfel:

private void exitClicked() {

System.exit(0);

private void fileOpen() {

FileDialog fDlg = new FileDialog(this, "Open a file",

FileDialog.LOAD);

fDlg.show();

private void redClicked() {

p.setBackground(Color.red);

}[1]

Deoarece într-un program putem avea foarte multe butoane şi meniuri este de
preferat ca fiecare buton să aibă propria sa apelare a interfeţei Command. Acest lucru
duce şi la mai bună funcţionalitate a programului, dar şi la un cod mai uşor de
întreţinut şi modificat.

40
În exemplul de mai jos am creat mici clase care implementează interfaţa
ActionListener.

class btnRed implements ActionListener {

public void actionPerformed(ActionEvent e) {

p.setBackground(Color.red);

class fileExit implements ActionListener {

public void actionPerformed(ActionEvent e) {

System.exit(0);

Acestea au fost înregistrate cu proprietatea listener în mod obişnuit.

mnuOpen.addActionListener(new fileOpen());

mnuExit.addActionListener(new fileExit());

btnRed.addActionListener(new btnRed());[1]

Pentru a reduce spaţiul de nume ocupat în memorie se declară o instanţă a


acestei interfeţe direct în locul unde avem nevoie:

btnRed.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

p.setBackground(Color.red); }

} );[1]

În aplicaţia Series_Analysis şablonul Command este exemplificat şi


implementat în fiecare clasă care are ca principal scop afişarea unei ferestre pe care
sunt puse elemente grafice, printre care şi butoane (JButton).

Pentru exemplificare o să folosesc fereastra Serie_Analysis – pentru clienţi,


unde am folosit implementarea prin unnamed inner class, fără să mai creez o clasă

41
specială pentru comandă, ci am declarat o instanţă ActionListener în locul unde am
folosit butonul.

Aici se găsesc două entităţi care au acţiuni: butonul Export şi lista de metode
(Figură 3.1.1-1). Lista de metode are ca efect afişarea graficului datele din sistem şi
metoda de analiză aleasă în prealabil, iar butonul Export va va deschide fereastra
care permite alegerea opţiunilor de printare/export (Figură 3.1.2.-1).

Implementarea butonului Export:

private void bexpActionPerformed(java.awt.event.ActionEvent evt) {

try {

new IOData().printData(txtpoza); }

catch (PrinterException ex) {

new ErrMsg().init_GUI(ex.toString()); }

Implementarea acţiunii listei de metode:

private void cbmethodsActionPerformed(java.awt.event.ActionEvent evt) {

if( Data_File.nrmatrix>0){

this.run(); }

else { ; }

......

public void run(){

if(cbmethods.getSelectedIndex()==0){

ImageIcon icon=new ImageIcon("C:\\Series_Analysis\\ ResourceFiles\\ Grafic.JPG");

txtpoza.setIcon(icon); }

else{

txtpoza.removeAll();

42
new ActionMethod().setActMethod(cbmethods.getSelectedIndex(),
cbmethods.getSelectedIndex()+"");

ImageIcon icon= new ImageIcon("C:\\Series_Analysis\\graphics\\


Grafic_Picture"+cbmethods.getSelectedIndex()+".PNG");

if(icon.getIconHeight()<1){

icon= new ImageIcon("C:\\Series_Analysis\\ResourceFiles\\Grafic.JPG");

txtpoza.setIcon(icon);

new ErrMsg().init_GUI("Error on creating Graphic!\nPlease try again!");}

else{

txtpoza.setIcon(icon); }

} }

Folosirea şi implementarea interfeţei ActionPerformed nu se aplică doar în


cazul entităţior jButton, plaja de utilizare fiind extinsă pentru orice entitate care poate
face motivul declanşării unui eveniment. Această situaţie este exemplificată mai sus
cu ajutorul obiectelor jComboBox, dar poate fi extinsă la majoritatea obiectelor
grafice: meniuri, submeniuri, checkbox-uri etc.

În acest caz evenimentul îl reprezintă apelul funcţiei run() care va executa metoda
selectată din lista pe care o reprezintă jComboList-ul cbmethods.

2.2.2 Şablonul Model – View - Controller


Şablonul Model-View-Controller doreşte să separe o componentă sau un
subsistem în trei părţi: model, vizualizare şi control facilitând în acest fel modificarea
sau implementarea fiecărui element în parte.

Un dezavantaj al acestui şablon de proiectare îl reprezintă extensibilitatea.


Pentru eficacitatea codului, în privinţa reutilizării, ar trebui separate părţile
componente în clase distincte: elementele de control puse întro clasă separată în
vederea modificării unor operaţii şi modalităţile de afişare puse în altă clasă –
deoarece putem avea mai multe reprezentări pentru acelaşi set de date (atribute al
entităţii cu care lucrăm).

43
Figură 2-1

Exemplificare acestui şablon, în cele mai multe cazuri, este realizată pe o


aplicaţie Swing reprezentând un sistem de logare pe un panou (jFrame).

O aplicaţie care foloseşte acest şablon trebuie să răspundă la trei întrebări:


Cum modifică aplicaţia modelul? Cum sunt reflectate modificările modelului în
partea de vizualizare? Cum sunt stabilite relaţiile dintre clasele modelului, vizualizării
şi controlului.[1]

Figură 2-2

- Modelul poate fi orice fel de tip date acceptat de Java şi reprezintă


orice fel de entitate care poate fi analizată şi proiectată.

public class Model {

private PropertyChangeSupport changeSupport= new PropertyChangeSupport(this);

private boolean loginStatus;

44
private String login;

private String password;

public Model() { loginStatus= false; }

public void setLogin(String login) { this.login= login; }

public void getPassword(String password) { this.password=password; }

public boolean getLoginStatus() { return loginStatus; } }[1]

- Partea de vizualizare este reprezentată de elementele Swing care


compun părţile afişabile grafic ale aplicaţiei (interfeţe Swing: jPanel,
jButton etc.)

package wrox.pattern.mvc;

import java.awt.GridLayout;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTextField;

public class CenterPanel extends JPanel {

private JTextField login= new JTextField(14);

private JTextField password= new JTextField(14)

public CenterPanel() {

setLayout(new GridLayout(2, 2));

add(new JLabel(“Login:”));

add(login);

add(new JLabel(“Password:”));

add(password);

public String getLogin() { return login.getText(); }

public String getPassword() { return password.getText(); }

45
}[1]

- Ultimul element al şablonului Model – View – Controller îl reprezintă


controlul. Acesta impune modelului comportamentul, îl controlează.

public LoginAction(Model model, CenterPanel panel ) {

this.model= model;

this.panel = panel;

public void actionPerformed(ActionEvent e) {

System.out.println(“Login Action: “+ panel.getLogin() +” “+ panel.getPassword());

model.login( panel.getLogin(), panel.getPassword() );

public class ExitAction extends AbstractAction {

public void actionPerformed(ActionEvent e) {

JFrame frame= new JFrame();

int response= JOptionPane.showConfirmDialog(frame,

“Exit Application?”, “Exit”,JOptionPane.OK_CANCEL_OPTION);

if (JOptionPane.YES_OPTION == response) { System.exit(0); }

}[1]

În această aplicaţie şablonul Model – View – Controller este exemplificat prin


sistemul de analiză şi prelucrare de date(Figură 3.1.1-1) şi graficele care rezultă în
urma analizei (Figură 3.1.8-1)deoarece datele introduse urmează un model, se pot
vizualiza şi se pot controla, manipula.

Exemplul următor se referă la fereastra Series_Analysis. Pentru acestea


modelul îl reprezintă o pereche denumere din fişierul încărcat în sistem, iar fiecare
număr este stocat pentru moment într-o variabilă în sistem şi este accesat pentru
prelucrare prin intermediul clasei Data_File.

46
package series_analysis;

/**

* @author Marius

*/

public class Data_File {

public static int nrmatrix=0;

public static String data_matrix[][] = new String[100][2];

public static int nrmethod=0;

public static String method[]= new String[30];

Pentru vizualizare fiecare fereastră se foloseşte de câte o clasă în care sunt


implementate diferite modalităţi de afişare:

- Pentru fereastra Series Analysis o metodă de analiză şi afişare va afişa


doar unele date şi un anumit grafic:

public void Gpaint(String a[][], int nrpoints, String nr) {

//paint lines

BufferedImage bi = new BufferedImage(440, 400,


BufferedImage.TYPE_INT_ARGB);

Graphics2D graph = bi.createGraphics();

graph.setStroke(drawingStroke);

graph.setPaint(Color.black);

graph.draw(line1);

graph.setPaint(Color.black);

graph.draw(line2);

graph.setPaint(Color.blue);

setareAxe(a,nrpoints);

47
//y points on axe

int l3y=360;

int axay=0;

for (axay=0;axay<=11;axay++){

double yy=miny+axay*(maxy-miny)/10;

if(axay==0){

graph.draw(new Line2D.Double(18, l3y, 23,l3y)); }

else{

graph.draw(new Line2D.Double(18, l3y, 435,l3y)); }

graph.drawString(yy+"", 5,l3y-2);

l3y=l3y-30; }

//x points on axe

int l3x=20;

int axax=0;

for (axax=0; axax<=11; axax++){

double xx=minx+axax*(maxx-minx)/10;

graph.draw(new Line2D.Double(l3x, 363, l3x,358));

graph.drawString(xx+"", l3x-4,375);

l3x=l3x+40; }

//display line between points

if(Integer.parseInt(a[nrpoints-1][1])>=Integer.parseInt(a[nrpoints-2][1])){

graph.setPaint(Color.GREEN); }

else{

graph.setPaint(Color.ORANGE); }

for(int i=1; i<nrpoints; i++){

48
Line2D lin = new Line2D.Double(scalarex(Integer.parseInt(a[i-1][0])),
scalarey(Integer.parseInt(a[i-1][1])), scalarex(Integer.parseInt(a[i][0])),
scalarey(Integer.parseInt(a[i][1])));

graph.draw(lin); }

//display points

for(int nrp=0;nrp<nrpoints;nrp++){

nrsx=(int) scalarex(Integer.parseInt(a[nrp][0]));

nrsy=(int) scalarey(Integer.parseInt(a[nrp][1]));

int y=nrsy;

int i=nrsx;

setPoint(graph, i,y, Integer.parseInt(a[nrp][0]), Integer.parseInt(a[nrp][1])); }

//set title and legend

......

graph.create();

//create the picture

try {

ImageIO.write(bi, "PNG", new File("C:\\Series_Analysis\\graphics\\


Grafic_Picture"+nr+".PNG")); }

catch (IOException ex) {

Logger.getLogger(Grafic.class.getName()).log(Level.SEVERE, null, ex);


} (Fereastră 3.1.8-1)

- În aceeaşi fereastră se va afişa datele prin intermediul unei alte metode


un alt grafic.

public void GpaintH(String a[][], int nrpoints, String nr) {

.....

graph.setPaint(Color.lightGray);

for(int i=1; i<nrpoints; i++){

49
Line2D lin = new Line2D.Double(scalarex(Integer.parseInt(a[i-1][0])),
scalarey(Integer.parseInt(a[i-1][1])), scalarex(Integer.parseInt(a[i][0])),
scalarey(Integer.parseInt(a[i][1])));

graph.draw(lin);

double k = scalarey(Integer.parseInt(a[i-1][1]));

for(; k<=360; k++){

for(double k2 = scalarey(Integer.parseInt(a[i][1])); k2<=360; k2++){

lin = new Line2D.Double(scalarex(Integer.parseInt(a[i-1][0])), k,


scalarex(Integer.parseInt(a[i][0])), k2);

graph.draw(lin); } }

....

graph.create();

//create the picture

}(Fereastră 2.2.2-3).

Figură 2-3

50
Partea de control se găseşte în clasa ActionMethod. Aici se găsesc toate
apelurile de metode din clasele necesare prelucrării datelor încărcate, cu excepţia
metodelor de vizualizare.

package series_analysis;

public class ActionMethod {

public void setActMethod(int k, String nr){

switch (k) {

case 1: new Grafic().Gpaint(Data_File.data_matrix, Data_File.nrmatrix, nr); break;

case 2: new GraficHasurat().GpaintH(Data_File.data_matrix, Data_File.nrmatrix, nr);


break; }

} }

2.2.3 Şablonul Template


Acest şablon face parte din categoria şabloanelor comportamentale. El se
aplică în situaţia în care se cunoaşte schema unui algoritm dar nu se cunosc paşii, ei
pot să varieze, să fie diferiţi. Şablonul Template implementează într-o clasă abstractă
schema algoritmului, iar paşii sunt declaraţi ca metode abstracte în această clasă,
urmând a fi implementaţi diferit în subclase concrete.

Al doilea caz de utilizare îl reprezintă cazul în care mai multe clase au un


comportament comun şi pentru a elimina scrierea de cod redundant, acest
comportament comun se factorizează întro clasă abstractă.

Un la treilea caz de utilizare îl constituie controlul extinderii subclaselor, şi anume: se


poate defini o metodă şablon care apelează aşa-numite operaţii-hook ("cârlige") în
puncte specifice, permiţând astfel ca extensiile să se realizeze doar în acele puncte.[7]

Exemplele următoare vor evidenţia structura şi aplicabilitatea şablonului:

51
Figură 3-1

 AbstractClass
o defineşte operaţiile primitive abstracte pe care subclasele urmează să
le implementeze;
o implementează o metodă şablon care defineşte scheletul unui algoritm.
Aceasta metodă apelează operaţiile primitive şi, eventual, alte operaţii
definite în AbstractClass sau in alte clase:

void AbstractClass::TemplateMethod() {

PrimitiveOperation1();

PrimitiveOperation2();

ConcreteClass - implementează operaţiile primitive pentru a realiza paşii specifici ai


algoritmului definit de TemplateMethod.[7]

Metodele şablon reprezintă o tehnica fundamentală de reutilizare a codului. Ele au o


importanţă deosebită în cadrul bibliotecilor de clase, deoarece constituie un mijloc de
factorizare a aspectelor comune ale comportamentului claselor respective.

Metodele şablon reprezintă o structură de control inversat. Aceasta înseamnă


că o clasă părinte apelează operaţiile unei subclase şi nu invers.

Este important pentru metodele şablon să se specifice clar care operaţii sunt
hook-uri (care POT fi redefinite) şi care sunt abstracte (care TREBUIE redefinite). În
vederea reutilizării eficiente a unei clase abstracte, proiectanţii subclaselor ei trebuie
să înţeleagă care sunt operaţiile concepute anume spre a fi redefinite. O subclasă

52
poate EXTINDE o operaţie din clasa părinte prin redefinirea acelei operaţii şi apelând
explicit operaţia omonimă din părinte:

void ClasaDerivata::Operatie( ) {

//secventa specifica pt. ClasaDerivata

ClasaParinte::Operatie();
}[7]

Un alt exemplu îl constituie desenarea unor triunghiuri diferite prin forma


lor.[1]

Figură 3-2

public abstract class Triangle {

Point p1, p2, p3;

public Triangle(Point a, Point b, Point c) {

p1 = a; p2 = b; p3 = c; }

public void draw(Graphics g) {

//This routine draws a general triangle

drawLine(g, p1, p2);

Point current = draw2ndLine(g, p2, p3);

53
closeTriangle(g, current); }

public void drawLine(Graphics g, Point a, Point b){

g.drawLine(a.x, a.y, b.x, b.y); }

//this routine has to be implemented

//for each triangle type.

abstract public Point

draw2ndLine(Graphics g, Point a, Point b);

public void closeTriangle(Graphics g, Point c) {

//draw back to first point

g.drawLine(c.x, c.y, p1.x, p1.y); }

}[1]

Această clasă salvează coordonatele celor trei linii, dar nu desenează decât pe
prima şi pe ultima, linia a doua fiind desenată de o subclasă.

public class stdTriangle extends Triangle {

public stdTriangle(Point a, Point b, Point c)

{ super(a, b, c); }

public Point draw2ndLine(Graphics g, Point a, Point b) {

g.drawLine(a.x, a.y, b.x, b.y);

return b;

} }

public class IsocelesTriangle extends Triangle {

public IsocelesTriangle(Point a, Point b, Point c)

{...}

. . . }[1]

În aplicaţia Series_Analysis şablonul Template se evidenţiază prin crearea


ferestrelor care definesc ferestrele:

54
public class MainWindows extends javax.swing.JFrame {

/** Creates new form MainWindows */

public MainWindows() {

initComponents();

new Centru().CentruFereastra(this);

this.setVisible(true);

afis();

Aceste clase extind şi definesc în mod particular clasa jFrame.

55
2.3 Implementare
Programul folosit pentru implementarea acestei aplicaţii este NetBeans 6.0.1.
Acest program are la bază limbajul de programare Java. Toate facilităţile şi
instrumentele oferite de limbajul Java le regăsim şi pe platforma NetBeans.

Entitatea de bază a acestui limbaj de programare este obiectul. La nivel


conceptual el este o entitate cu responsabilităţi care se află întro anumită stare, are un
anumit comportament şi o identitate. La nivel de implementare el reprezintă un set de
date şi metode (funcţii membre).

Obiectul este o instanţă a unei clase, ceea ce implică încărcarea atributelor datelor
cu valori particulare.

Clasa este formată dintr-un grup de obiecte de acelaşi tip, este un prototip pentru
mai multe obiecte şi defineşte date şi metode.

Cea mai vizibilă tehnologie folosită pentru proiectare este tehnologia Swing.
Ea face parte dintrun proiect mai amplu numit JFC (Java Foundation Classes) care
pune la dispoziţie o serie întreagă de facilităţi pentru scrierea de aplicaţii cu o
interfaţă grafică mult îmbogăţită funcţional şi estetic faţă de vechiul model AWT. In
JFC sunt incluse următoarele:

• Componente Swing

Sunt componente ce înlocuiesc şi în acelaşi timp extind vechiul set oferit de


modelul AWT.

• Look-and-Feel

Permite schimbarea înfăţişării şi a modului de interacţiune cu aplicaţia în


funcţie de preferinţele fiecăruia. Acelaşi program poate utiliza diverse moduri Look-
and-Feel, cum ar fi cele standard Windows, Mac, Java, Motif sau altele oferite de
diverşi dezvoltatori, acestea putând fi interschimbate de către utilizator chiar la
momentul execuţiei .

• Accessibility API

Permite dezvoltarea de aplicaţii care să comunice cu dispozitive utilizate de


către persoane cu diverse tipuri de handicap, cum ar fi cititoare de ecran, dispozitive
de recunoaştere a vocii, ecrane Braille, etc.

• Java 2D API

56
Folosind Java 2D pot fi create aplicaţii care utilizează grafică la un nivel
avansat. Clasele puse la dispoziţie permit crearea de desene complexe, efectuarea de
operaţii geometrice (rotiri, scalări, translaţii, etc.), prelucrarea imagini, tipărire, etc.

•Drag-and-Drop

Oferă posibilitatea de a efectua operaţii drag-and-drop între aplicaţii Java şi


aplicaţii native.

•Internaţionalizare

Internaţionalizarea şi localizarea aplicaţiilor sunt două facilităţi extrem de


importante care permit dezvoltarea de aplicaţii care să poată fi configurate pentru
exploatarea lor în diverse zone ale globului, utilizând limba şi particularităţile legate
de formatarea datei, numerelor sau a monedei din zona respectivă.

Unul din principalele deziderate ale tehnologiei Swing a fost să pună la


dispoziţie un set de componente GUI extensibile care să permită dezvoltarea rapidă
de aplicaţii Java cu interfaţă grafică competitivă din punct de vedere comercial.
Pentru a realiza acest lucru, API-ul oferit de Swing este deosebit de complex având
17 pachete în care se găsesc sute de clase şi interfeţe. Lista completă a pachetelor din
distribuţia standard 1.4 este dată mai jos:

javax.accessibility

javax.swing.text.html

javax.swing.plaf.basic

javax.swing.border

javax.swing.text.rtf

javax.swing.plaf.multi

javax.swing.event

javax.swing.undo

javax.swing.text

javax.swing.plaf

javax.swing

javax.swing.text.parser

57
javax.swing.plaf.metal

javax.swing.colorchooser

javax.swing.tree

javax.swing.table

javax.swing.filechooser[4]

Evident, nu toate aceste pachete sunt necesare la dezvoltarea unei aplicaţii, cel
mai important şi care conţine componentele de bază fiind javax.swing

Componentele folosite pentru crearea interfeţelor grafice Swing pot fi grupate:

• Componente atomice

JLabel, JButton, JCheckBox, JRadioButton, JToggleButton, JSlider, JProgressBar,


JSeparator

• Componente complexe

JTable, JTree, JComboBox, JSpinner, JList, JFileChooser, JOptionPane

• Componente pentru editare de text

JTextField, JFormattedTextField, JPasswordField, JtextAre, JEditorPane, JTextPane

• Meniuri

JMenuBar, JMenu, JPopupMenu, JMenuItem, JcheckboxMenuItem,


JRadioButtonMenuItem

• Containere intermediare

JPanel, JScrollPane, JSplitPane, JTabbedPane, JdesktopPan, JToolBar

• Containere de nivel înalt

JFrame, JDialog, JWindow, JInternalFrame, Japplet

Pentru a fi afişate pe ecran componentele grafice ale unei aplicaţii trebuie


plasate pe o suprafaţă de afişare (container). Fiecare componentă poate fi conţinută
doar într-un singur container, adăugarea ei pe o suprafaţă nouă de afişare determinând
eliminarea ei de pe vechiul container pe care fusese plasată. Întrucât containerele pot
fi încapsulate în alte containere, o componentă va face parte la un moment dat dintro
ierarhie. Rădăcina acestei ierarhii trebuie să fie un aşanumit container de nivel înalt,
care este reprezentat de una din clasele JFrame, JDialog sau Japplet.

58
În general orice aplicaţie Java independentă bazată pe Swing conţine cel puţin
un container de nivel înalt reprezentat de fereastra principală a programului, instanţă a
a clasei JFrame.

Simplificat, un obiect care reprezintă o fereastră Swing conţine o zonă care


este rezervată barei de meniuri şi care este situată de obicei în partea superioară şi
corpul ferestrei pe care vor fi plasate componentele.

În categoria componentelor atomice includem componentele Swing cu


funcţionalitate simplă, a căror folosire este în general asemănătoare cu a
echivalentelor din AWT. Aici includem:

• Etichete: JLabel

•Butoane simple sau cu două stări: JButton, JCheckBox, JRadioButton,


JToggleButton; mai multe butoane radio pot fi grupate folosind clasa ButtonGroup,
pentru a permite selectarea doar a unuia dintre ele.

• Componente pentru progres şi derulare: JSlider, JProgressBar, JScrollBar

• Separatori: JSeparator

•Componente pentru editare de text

•Componentele Swing pentru afişarea şi editarea textelor sunt grupate într-o


ierarhie ce are ca rădăcină clasa JtextComponent din pachetul javax.swing.text.

• Text simplu pe o singură linie

– JTextField - Permite editarea unui text simplu, pe o singură linie.

– JPasswordField - Permite editarea de parole. Textul acestora va fi ascuns, în locul


caracterelor introduse fiind afişat un caracter simbolic, cum ar fi ’*’.

– JFormattedTextField - Permite introducerea unui text care să respecte un anumit


format, fiind foarte utilă pentru citirea de numere, date calendaristice etc. Este folosită
împreună cu clase utilitare pentru formatarea textelor, cum ar fi NumberFormatter,
DateFormatter, MaskFormatter etc. Valoarea conţinută de o astfel de componentă va
fi obţinută/setată cu metodele getValue, respectiv setValue ¸si nu cu cele uzuale
getText, setText.

• Text simplu pe mai multe linii

– JTextArea - Permite editarea unui text simplu, pe mai multe linii. Orice atribut legat
de stil, cum ar fi culoarea sau fontul, se aplică întregului text şi nu poate fi specificat
doar unei anumite porţiuni. Uzual, o componentă de acest tip va fi inclusă întrun

59
container JScrollPane, pentru a permite navigarea pe verticală şi orizontală dacă
textul introdus nu încape în suprafaţa alocată obiectului. Acest lucru este valabil
pentru toate componentele Swing pentru care are sens noţiunea de navigare pe
orizontală sau verticală, nici una neoferind suport intrinsec pentru această operaţiune.

Clasa Jlist descrie o listă de elemente dispuse pe una sau mai multe coloane,
din care utilizatorul poate selecta unul sau mai multe. Uzual un obiect de acest tip va
fi inclus întrun container de tip JScrollPane.

Clasa JComboBox este similară cu JList, cu deosebirea că permite doar


selectarea unui singur articol, acesta fiind şi singurul permanent vizibil. Lista
celorlalte elemente este afişată doar la apăsarea unui buton marcat cu o săgeată, ce
face parte integrantă din componentă. JComboBox funcţionează după aceleaşi
principii ca şi clasa JList. Iniţializarea se face dintr-un vector sau folosind un model
de tipul ComboBoxModel, fiecare element putând fi de asemenea reprezentat diferit
prin intermediul unui obiect ce implementează aceeaşi intefaţă ca şi în cazul listelor:
ListCellRenderer.

O diferenţă notabilă constă în modul de selectare a unui articol, deoarece


JcomboBox permite şi editarea explicită a valorii elementului, acest lucru fiind
controlat de metoda setEditable. Evenimentele generate de obiectele JComboBox
sunt de tip ItemEvent generate la navigarea prin listă, respectiv ActionEvent generate
la selectarea efectivă a unui articol.

Clasa JTable permite crearea de componente care să afişeze o serie de


elemente într-un format tabelar, articolele fiind dispuse pe linii şi coloane. Un tabel
poate fi folosit doar pentru afişarea formatată a unor date, dar este posibilă şi editarea
informaţiei din celulele sale. De asemenea, liniile tabelului pot fi marcate ca selectate,
tipul selecţiei fiind simplu sau compus, tabelele extinzând astfel funcţionalitatea
listelor. Deşi clasa JTable se găseşte în pachetul javax.swing, o serie de clase şi
interfeţe necesare lucrului cu tabele se găsesc în pachetul javax.swing.table, acesta
trebuind aşadar importat.

În Swing, există câteva soluţii simple pentru afişarea unei imagini, cea mai
utilizată fiind crearea unei etichete (JLabel) sau a unui buton (JButton) care să aibă
setată o anumită imagine pe suprafaţa sa. Imaginea respectivă trebuie creată folosind
clasa ImageIcon.

ImageIcon img = new ImageIcon("poza.jpg");

JLabel label = new JLabel(img); [8]

60
2.4 Explicitare claselor

About
Aceasta este clasa în care este definită fereastra de mai jos

Figură 2.4-1

Clasa About extinde clasa javax.swing.Jframe din Java.

Aici sunt afişate câteva date despre aplicaţie şi emblema Universităţii Spiru Haret.

ActionMethod
Aceasta este clasa responsabilă pentru analiza şi afişarea rezultatelor analizei conform
cu metoda selectată.

Conţinutul clasei este următorul:

package series_analysis;

public class ActionMethod {

public void setActMethod(int k, String nr){

switch (k) {

case 1: new Grafic().Gpaint(Data_File.data_matrix, Data_File.nrmatrix,


nr); break;

case 2: new Grafic2().Graph(Data_File.data_matrix, Data_File.nrmatrix,


nr); break;}}}

În momentul când se selectează o metodă se apelează această clasă, iar parametrul k


indică ce metodă să se execute.

61
Tot această clasă suferă modificări în procesul de update prin suprascrierea
conţinutului ei.

Procesul de update se realizează astfel:

- se reţine conţinutul acestui fişier până la seria de 3 acolade }}} într-o


variabilă de tip şir de caractere

- se adaugă o nouă linie (un nou case): se adaugă textul case + numărul
de metode existente incrementat cu o unitate + : + comanda care va
analiza datele şi le va şi afişa + ; break; şi cele 3 acolade }}}

- se va scrie conţinutul acestei variabile în acest fişier suprasciind tot


conţinutul

- se va rula un fişier de tip .bat extern care execută următoarele comenzi

1. va închide aplicaţia

2. compilează această clasă

3. copiază fişierul rezultat în urma compilării în arhiva de tip .jar


care este, de fapt, fişierul executabil pentru aplicaţie

În acest moment aplicaţia poate fi pornită şi se poate folosi noua metodă


adăugată prin procesul descris mai sus.

BrowseFile
Aceasta este clasa în care este definită fereastra pentru selectarea fişierelor care
conţin datele pe care vrem să le analizăm în aplicaţie prin metodele disponibile.

Clasa BrowseFile extinde clasa javax.swing.Jframe din Java.

Apăsând butonul SelectFile se va reţine calea către fişier pentru a fi folosit ulterior
pentru extragerea datelor din el.

Metoda care face acest lucru este:

private File GetPath(){

File file=filech.getSelectedFile();

return file;

62
Figură 2.4-2

BrowseUpdate
Aceasta este clasa în care este definită fereastra pentru selectarea fişierelor care
conţin metodele pe care vrem să le adăugăm în aplicaţie prin prin procesul de update.

Clasa BrowseUpdate extinde clasa javax.swing.Jframe din Java.

Această clasă este asemănătoare cu precedenta clasă, BrowseFile.

Apăsând butonul SelectFile se va reţine calea către fişier pentru a fi folosit ulterior
pentru copierea şi prelucrarea lui.

Metoda care face acest lucru este:

private void bupdateActionPerformed(java.awt.event.ActionEvent evt) {

UpdateApp.fisiersrc=fchfile.getSelectedFile();

this.dispose();

new UpdateApp().setVisible(true);

63
După ce calea către acest fişier este reţinută, această fereastră se închide şi se va
reafişa fereastra pentru update.

Figură 2.4-1

Centru
Această clasă conţine metoda care afişează o fereastră dată ca parametru în
centrul ecranului.

public class Centru {

public void CentruFereastra(javax.swing.JFrame f){

Toolkit kit = Toolkit.getDefaultToolkit();

Dimension screenSize = kit.getScreenSize();

int latime = (int)screenSize.getWidth(); // latimea ecranului

int inaltime = (int)screenSize.getHeight(); // inaltimea ecranului

f.setLocation(((latime / 2) - (f.getWidth()/2)),((inaltime / 2) - (f.getHeight()/2)));

}}[12]

64
Copy_File
În această clasă se află metoda care copiază fişierele de la adresa curentă în folder-ul
indicat de variabila de mediu CLASSPATH pentru Java în procesul de update.

Metoda verifică dacă s-au mai selectat fişiere pentru update sau acesta este primul.

Deoarece adresele fişierelor se scriu într-un fişier .bat care se va rula ulterior este
important să se ştie dacă pentru sesiunea curentă s-au mai selectat fişiere pentru
update – caz în care adresele noilor fişiere selectate se vor adăuga în fişier fără ca
acesta să fie suprascris sau se va suprascrie conţinutul acestui fişierului cu adresa
fişierului care constituie un update.

Acest lucru se realizează prin secvenţele de cod de mai jos:

- pentru suprascriere conţinut fişier

path1= "C:\\Series_Analysis\\src\\series_analysis\\";

path1 = path1.concat(f.getName());

cpsrc="COPY \""+f.getAbsolutePath()+"\" \""+path1+"\"";

path2 = "C:\\Series_Analysis\\ResourceFiles\\Update.bat";

File copyFile = new File(path2);

new IOData().setActionMethod(copyFile, cpsrc);

- pentru adăugare adresă la fişier fără suprascriere

path1= "C:\\Series_Analysis\\src\\series_analysis\\";

path1 = path1.concat(f.getName());

cpsrc="COPY \""+f.getAbsolutePath()+"\" \""+path1+"\"";

path2 = "C:\\Series_Analysis\\ResourceFiles\\Update.bat";

File copyFile = new File(path2);

new IOData().setActionMethod(copyFile, cpsrc,1);

Diferenţa este la apelul IOData().setActionMethod(copyFile, cpsrc,1);

- dacă metoda are doar 2 parametri (fişierul cu adrese şi fişierul care se


va copia) atunci fişierul cu adrese se va suprascrie.

- dacă apare şi al treilea parametru atunci se va adăuga fără suprascriere

65
Data_File
Aceasta este clasa în care se reţin datele care urmează sa fie prelucrate şi afişate (în
variabilele nrmatrix şi data_matrix) şi lista de metode care se pot folosi pentru
analiza şi afişarea datelor.

- nrmatrix reprezintă numărul maxim de elemente care sunt încărcate


în sistem, iar data_matrix lista cu aceste date

public static int nrmatrix=0;

public static String data_matrix[][] = new String[100][2];

- nrmethod reprezintă numărul de metode încărcate în sistem, iar


method lista cu aceste metode

public static int nrmethod=0;

public static String method[]= new String[30];

ErrMsg
Aceasta este clasa în care este definită fereastra de mai jos.

Figură 2.4-4

Clasa ErrMsg extinde clasa javax.swing.Jframe din Java.

Aici sunt afişate câteva erorile care apar în aplicaţie şi o iconiţă de atenţionare.

Grafic
Aceasts este una dintre clasele care analizează şi afişează datele.

Folosind acestă clasă se vor afişa punctele pe ecran fără a se prelucra.

66
Este recomandat ca pentru toate metodele folosite să se prelucreze datele, să se
depună în clasa Data_File şi să se apeleze această metodă pentru datele din clasa mai
sus amintită.

În această clasă se desenează axele, punctele şi linia care uneşte aceste puncte.

Pentru că datele analizate au valori diferite – de la numere subunitare până la numere


foarte mari, tot această clasă realizează o scalare a acestor numere pentru a se încadra
cât mai bine în zona pentru afişare a graficului.

Fiind o proiecţie 2D cele două funcţii pentru scalarea pe axele OX şi OY sunt:

private double scalarex(int nrx){

//scale coordonate x

pasx=(maxx-minx)/400;

double nrs1x=(nrx-minx)/pasx;

nrs1x=nrs1x+x0;

return nrs1x;

private double scalarey(int nry){

//scale coordonate y

pasy=(maxy-miny)/300;

double nrs1y=(nry-miny)/pasy;

nrs1y=360-nrs1y;

return nrs1y;

Tot această clasă transformă graficul intr-un fişier .png – format imagine şi poate fi
prelucrat şi vizualizat şi după ce s-a închis programul.

try {

ImageIO.write(bi, "PNG", new File (" C:\\ Series_Analysis\\ graphics\\


Grafic_Picture"+nr+".PNG"));

67
} catch (IOException ex) {

Logger.getLogger(Grafic.class.getName()).log(Level.SEVERE, null, ex);

Hdata
Aceasta este clasa în care este definită fereastra de mai jos.

Figură 2.4-5

Clasa Hdata extinde clasa javax.swing.Jframe din Java.

Aici sunt afişate fişierele cu date care s-au încărcat în aplicaţie spre a fi analizate şi un
buton de export al tabelului.

IOData
În această clasă se realizează toate operaţiile care necesită transfer de date din fişier în
aplicaţie şi invers.

Metoda get_data returnează textul dintr-un fişier linie cu linie.

public String get_data(File log_file){

.....

try {

while (( line = input.readLine()) != null){

68
contents.append(line);

contents.append(System.getProperty("line.separator"));

....

return contents.toString();

Metoda set_data scrie în fişier logurile şi/sau istoricul fişierelor cu date importate.

public void set_data(File log_file, String frame, String action) throws


FileNotFoundException, IOException {

.......

Calendar clnd = Calendar.getInstance();

String log="\n"+clnd.getTime().toLocaleString()+"-"+frame+"-
"+action+"-";

FileWriter fstream = new FileWriter(log_file, true);

BufferedWriter out = new BufferedWriter(fstream);

out.append(log);

out.close();

Metoda convert StringToList extrage datele din fişierele de istoric şi le inserează într-
un tabel.

public void convertStringToList(File document, String separator1, String


separator2, javax.swing.table.DefaultTableModel dtmtable, javax.swing.JTable
tbl) {

StringTokenizer stNewLine = new StringTokenizer(text, separator1);

while (stNewLine.hasMoreTokens()) {

String line = stNewLine.nextToken();

StringTokenizer st = new StringTokenizer(line, separator2);

69
while (st.hasMoreTokens()) {

data=st.nextToken();

window=st.nextElement().toString();

action=st.nextToken().toString();

dtmtable.insertRow(nr_row++,new String[]{data,window,action} );

Metoda SeparatorData setează separatorul dintre date cu cel selectat din listă.

De exemplu dacă în listă este scris , (comma) se va seta separatorul „ , ”.

public String SeparatorData(String f){

String path="";

StringTokenizer stNewLine = new StringTokenizer(f, "(");

path = stNewLine.nextToken().toString();

return path;

Metoda printData (tabel) exportă/imprimă tabelul.

public void printData(javax.swing.JTable t) throws PrinterException{

t.print();

Metoda printData (label) exportă/imprimă graficul afişat într-un jLabel.

public void printData(final javax.swing.JLabel pnl) throws PrinterException{

....

pj.setPrintable(new Printable() {

public int print(Graphics pg, PageFormat pf, int pageNum) {

Graphics2D g2 = (Graphics2D) pg;

g2.translate(pf.getImageableX(), pf.getImageableY());

70
pnl.paint(g2);

return Printable.PAGE_EXISTS;

....

pj.print();

pnl.print(pnl.getGraphics());

Metoda setActionMethod scrie loguri în fişierele de istoric suprascriin fişierul.

public void setActionMethod(File log_file, String act) throws IOException {

FileWriter fstream = new FileWriter(log_file);

BufferedWriter out = new BufferedWriter(fstream);

out.append(act);

out.close();

Metoda setActionMethod cu 3 parametrii scrie loguri în fişierele de istoric adăugând


la conţinutul deja existent al fişierului.

public void setActionMethod(File log_file, String act, int i)throws IOException {

FileWriter fstream = new FileWriter(log_file, true);

BufferedWriter out = new BufferedWriter(fstream);

out.append(act);

out.close();

Metoda getActionContent reţine conţinutul clasei ActionMethod până întâlneşte


seria de 3 acolade (}}}).

public String getActionContent(String path){

String str="", s="";

StringTokenizer st = new StringTokenizer(path, "}");

71
while (st.hasMoreTokens()) {

s=st.nextToken().toString();

if(!s.equals(System.getProperty("line.separator"))){

str = str.concat(s);

else ;

return str;

Metoda AddMethod rescrie fişierul ActionMethod cu noile metode adăugate.

Pentru mai multe detalii privind procesul de update a se vedea secţiunea


2.4Explicitarea claselor – subsecţiunea ActionMethod.

public void AddMethod(File log_file, String name) throws FileNotFound


Exception, IOException {

String log="\n"+name;

FileWriter fstream = new FileWriter(log_file, true);

BufferedWriter out = new BufferedWriter(fstream);

out.append(log);

out.close();

Logs
Aceasta este clasa în care este definită fereastra de mai jos.

Clasa Logs extinde clasa javax.swing.Jframe din Java.

Aici este afişat istoricul accesărilor funcţionalităţilor din aplicaţie spre şi un buton de
export al tabelului.

72
Figură 2.4-6

Main
Clasa Main este clasa principală a aplicaţiei şi prin intermediul ei se apelează
majoritatea celorlalte clase. Aceasta are responsabilitatea apelării clasei care deschide
practic aplicaţia.

public class Main {

public static void main(String[] args) {

new MainWindows()setVisible(true);

MainWindows
Aceasta este clasa în care este definită fereastra de mai jos.

Clasa MainWindows extinde clasa javax.swing.Jframe din Java.

Aici este afişat graficul pentru datele analizate, meniul aplicaţiei, lista de metode şi un
buton de imprimare/export pentru graficul generat.

73
Figură 2.4-7

Această clasă reprezintă, de fapt, fereastra principală a aplicaţiei Series Analysis.

SetData
Aceasta este clasa în care este definită fereastra de mai jos.

Figură 2.4-8

Clasa SetData extinde clasa javax.swing.Jframe din Java.

În această clasă se află implementată funcţionalitatea de a selecta separatorul dintre


datele din fişierul folosit în analiză.

74
Metoda care oferă lista de separatori de date este următoarea:

private void setSeparator(){

cbsepar.addItem(","+"(comma)");

cbsepar.addItem("|"+"(pipeline)");

cbsepar.addItem("."+"(dot)");

cbsepar.addItem("-"+"(line)");

cbsepar.addItem("_"+"(underline)");

cbsepar.addItem(" "+"(TAB)");

cbsepar.addItem(" "+"(space)");

UpdateApp
Aceasta este clasa în care este definită fereastra de mai jos.

Figură 2.4-9

Clasa UpdateApp extinde clasa javax.swing.Jframe din Java.

În această clasă se află implementată funcţionalitatea de a pregăti pentru


copiere/update fişierele care trebuiesc compilate şi adăugate aplicaţiei.

Tot în acestă clasă se va trimite către clasa IOData numele metodei care va fi
adăugată în fişierul cu lista de metode şi apoi folosită în aplicaţie.

75
UserManual
Aceasta este clasa în care este definită fereastra de mai jos.

Figură 2.4-10

Clasa UserManual extinde clasa javax.swing.Jframe din Java.

În această clasă se află implementată funcţionalitatea de a afişa manualul de utilizare


al aplicaţiei şi de a-l parcurge pagină cu pagină..

Parcurgerea paginilor manualului de utilizare se face cu ajutorul slider-ului din partea


de sus a ferestrei. Când cursorul ajunge în dreptul unui număr se va afişa pagina cu
numărul respectiv.

Metoda care realizează acest lucru este:

private void spgStateChanged(javax.swing.event.ChangeEvent evt) {

poza = new ImageIcon("C:\\Series_Analysis\\ResourceFiles\\ UserManual\\


UserManual"+spg.getValue()+".PNG");

txtpg.setIcon(poza);

scrp.setViewportView(txtpg);

76
În acest capitol au fost prezentate şabloanele de proiectare care stau la baza realizării
acestei aplicaţii.

Pe lânga aceste lucruri au fost evidenţiate şi detaliile implementării propriu-zise a


aplicaţiei: cazuri de utilizare, diagrame sau explicitarea fiecărei clase în parte care
compune acest proiect.

77
CAPITOLUL 3 - UTILIZARE

În acest capitol, Capitolul 3, doresc să prezint fiecare detaliu al aplicaţiei din


perspectiva unui utilizator care nu cunoaşte noţiunile de matematică sau informatică
prezentate în capitolele anterioare.

Acest lucru doresc să îl prezint sub forma unui manual de utilizare al aplicaţiei pentru
a facilita totodată folosirea programului.

Tot în acest capitol este prezentat şi programul în care s-a dezvoltat această aplicaţie.

3.1 Manual de utilizare

3.1.1 Series_Analysis
Aceasta este fereastra principală. Aici se vor alege metodele de analiză a datelor
precum şi modul de afişare (graficul).

Figură 3.1.1-1

78
Această pagină dispune de un meniu – în partea superioară a ferestrei, de o listă de
metode – în partea dreapă-sus, de un buton pentru exportul graficului – sub lista de
metode, emblema Universităţii Spiru Haret şi numele absolventului – pe partea
dreaptă a ferestrei şi zona de afişare a graficului – reprezentând cea mai mare zonă a
ferestrei.

Elementele Vizuale

 Meniu

 Meniul File

Figură 3.1.1-2

- Submeniul Logs

Acest meniu oferă acces către secţiunea de vizualizare a logurilor. Un click pe acest
meniu va deschide fereastra Logs.

De asemenea, secţiunea loguri poate fi accesată şi prin combinaţia de taste CTRL+L.

Pentru a vizualiza detalii despre loguri a se vedea secţiunea 2.5.3 View Logs.

- Submeniul History Data

Acest meniu oferă acces către secţiunea de vizualizare a istoricului datelor introduse
în aplicaţie şi analizate. Un click pe acest meniu va deschide fereastra History Data.

De asemenea, secţiunea de istoric date poate fi accesată şi prin combinaţia de taste


CTRL+H.

Pentru a vizualiza detalii despre istoricul datelor analizate a se vedea secţiunea 2.5.4
History Data.

- Submeniul Update

Acest meniu oferă acces către secţiunea pentru actualizarea aplicaţiei cu noi metode
de analiză şi afişare a datelor . Un click pe acest meniu va deschide fereastra Update.

79
De asemenea, secţiunea pentru update poate fi accesată şi prin combinaţia de taste
CTRL+U.

Pentru a vizualiza detalii despre actualizare a se vedea secţiunea 2.5.5 Update.

- Submeniul Exit

Acest meniu închide aplicaţia.

Este recomandat să se închidă aplicaşia din acest meniu şi nu din butonul


deoarece procedura care închide aplicaţia este în strânsă legătură cu cea de update,
actualizarea realizându-se doar cand aplicaţia este oprită. De asemenea, ieşirea din
aplicaţie se poate face şi prin combinaţia de taste CTRL+E.

 Meniul Analysis

Figură 3.1.1-3

- Submeniul Chart

Acest meniu oferă acces către secţiunea de vizualizare a datelor sub forma unui
grafic. Un click pe acest meniu va activa lista cu metode aflată în partea dreaptă a
ferestrei. De asemenea, secţiunea grafic poate fi accesată şi prin combinaţia de taste
CTRL+G.

Pentru a vizualiza detalii despre grafice a se vedea secţiunea 2.5.8 Grafice.

- Submeniul Data

Acest meniu oferă acces către secţiunea de încărcare a datelor în aplicaţie pentru a fi
analizate. Un click pe acest meniu va deschide fereastra Load Data. De asemenea,
secţiunea de istoric date poate fi accesată şi prin combinaţia de taste CTRL+S.

Pentru a vizualiza detalii despre încărcarea datelor în aplicaţie a se vedea secţiunea


2.5.7 Load Data.

80
 Meniul Help

Figură 3.1.1-4

- User Manual

Acest meniu oferă acces către secţiunea de vizualizare a manualului de utilizare a


aplicaţiei. Un click pe acest meniu va afişa o fereastră în care se poate consulta
manualul pentru utilizarea aplicaţiei.

Pentru a vizualiza detalii despre manual de utilizare a se vedea secţiunea 2.5.9 User
Manual.

- About

Acest meniu oferă acces către secţiunea de informare asupra acestui program. Un
click pe acest meniu va deschide fereastra About.

Pentru a vizualiza detalii despre această pagină a se vedea secţiunea 2.5.10 About.

 Metode

Figură 3.1.1-5

După ce datele au fost încărcate în sistem se accesează meniul Chart.

În acest moment lista de metode devine accesibilă şi se populează cu numele fiecărei


metode care poate fi folosită în aplicaţie.

Dacă numele metodei se va modifica în fişierul care conţine numele metodelor,


atunci acest lucru va fi vizibil la un nou eveniment care conduce la repopularea listei
cum ar fi o nouă accesare a meniului Chart sau o repornire a aplicaţiei.

Dacă se modifică numărul de metode sau ordinea lor în fişierul care conţine lista de
metode atunci impactul acestor modificări se reflectă în funcţionalitatea aplicaţiei
astfel:

81
- dacă de modifică ordinea se va folosi o altă metodă pentru acest nume
deoarece în aplicaţie metodele nu pot fi interschimbate între ele.

- dacă se vor elimina nume de metode funcţionalităţile metodelor


respective nu vor mai putea fi folosite deşi ele încă există în aplicaţie.

- dacă se vor adaugă nume de metode noi în acest fişier,acestea ve vor


afla în lista de metode, dar în momentul folosirii vor genera un mesaj
de eroare şi nu se va face analiză şi vizualiza de date. Pentru mai multe
detalii despre eroarea generată a se vedea secţiunea 2.5.11 Eroare.

 Export

După alegerea metodei şi generarea graficului acesta se poate imprima sau exporta în
fişier. Pentru acest lucru se apasă butonul Export.

Pentru mai multe detalii despre export se vedea secţiunea 2.5.2 Export

 Alte elemente grafice

Figură 3.1.1-6

În partea dreaptă a ferestrei sunt afişate emblema Universităţii Spiru Haret şi,
dedesubt, numele absolventului.

Aceste elemente un se pot edita sau schimba.

82
Figură 3.1.1-7

Cea mai mare parte a ferestrei este ocupată de grafic.

Aici sunt afişate graficele generate de toate metodele disponibile în aplicaţie.

Pentru detalii privind generarea şi afişarea unui grafic a se vedea secţiunea 2.5.8
Grafice.

3.1.2 Export
Apăsarea butonului Export are ca efect afişarea unei ferestre cu opţiuni de
imprimare.

83
Figură 3.1.2-1

Aici se va alege ca imprimantă numele doPDF v7 şi se apasă butonul OK.

doPDF este un produs software extern adiţional aplicaţiei care permite printarea
fişierelor în fişier de tip pdf.

Acest tip de fişiere se pot deschide cu programul Adobe Reader.

Aceste două programe, doPDF şi Adobe Reader trebuiesc instalate odată cu


instalarea acestui program pentru a beneficia de exportul şi vizualizarea datelor întrun
fişier cu extensia pdf.

După apăsarea butonului Ok va apărea o fereastră cu opţiuni ale programului doPDF.

84
Figură 3.1.2-2

Aici se poate alege calea şi numele fişierului în care va fi salvat graficul prin
accesarea butonului Browse.. sau prin editarea câmpului File name.

De asemenea pot fi utilizate şi alte opţiuni precum folosirea implicită a unui folder
pentru salvarea fişierelor sau deschiderea automată a unui fişier atunci când a fost
generat.

Pentru generarea fişierului se apasă butonul OK.

85
Figură 3.1.2-3

3.1.3 View Logs


Aceasta este pagina în care se poate vizualiza istoricul accesărilor paginilor şi al
funcţionalităţilor din acest proiect.

În această pagină se pot vizualiza datele sub forma unui tabel care conţine 3 coloane:

- prima coloană (Date/Time) afişează data şi ora la care s-a produs


evenimentul

- a doua coloană (File) afişează numele ferestrei în care s-a produs


evenimentul înregistrat

- a treia coloană (Path) reprezintă evenimentul înregistrat

Coloanele nu se pot edita sau sorta, dar se pot interschimba între ele. Implicit sortarea
datelor se face după data înregistrării evenimentelor.

86
Figură 3.1.3-1

Apăsarea butonului Export are ca efect printarea sau salvarea istoricului accesărilor
în fişier.

Pentru mai multe detalii despre export a se vedea secţiunea 2.5.2 Export.

3.1.4 History Data


Aceasta este pagina în care se poate vizualiza istoricul fişierelor cu date importate în
proiect.

În această pagină se pot vizualiza datele sub forma unui tabel care conţine 3 coloane:

- prima coloană (Date/Time) afişează data şi ora la care s-a încărcat


fişierul

- a doua coloană (File) afişează numele fişierului care s-a încărcat

- a treia coloană (Path) reprezintă cale fişierului încărcat

Coloanele nu se pot edita sau sorta, dar se pot interschimba între ele. Implicit sortarea
datelor se face după data încărcării fişierelor în sistem.

87
Figură 3.1.4-1

Apăsarea butonului Export are ca efect printarea sau salvarea istoricului încărcărilor
de date în fişier.

Pentru mai multe detalii despre export a se vedea secţiunea 2.5.2 Export.

3.1.5 Update
Aceasta este pagina în care se pot încărca fişiere cu noi funcţionalităţi în proiect.

Figură 3.1.5-1

Pentru a putea adăuga noi funcţionalităţi aplicaţiei trebuie adăugat fişierul(e) care le
conţin. Pentru acest lucru se apasă butonul Browse.

Acesta are ca efect ascunderea acestei ferestre şi afişarea unei alte ferestre care
permite selectarea fişierului.

Pentru mai multe detalii privind selecţia fişierelor a se vedea secţiunea 2.5.6 Browse.

88
După selectarea fişierului această fereastră va reapărea cu rumătoarele modificări:

- în partea dreaptă a câmpului Source File se va afişa calea către fişier.

- butonul Update va fi accesibil

Figură 3.1.5-2

Dacă checkbox-ul din stânga butonului Update este bifat atunci câmpurile Method
Name şi Command se vor activa şi vor putea fi editate.

Aici se vor completa numele metodei şi comanda în limbajul de programare java care
va analiza şi afişa graficul.

În cazul în care sunt mai multe fişiere care trebuiesc încărcate nu se va bifa acest
checkbox. Fişierul care conţine comanda se va încărca ultimul.

După ce fişierul este gata pentru a fi uploadat în sistem se apasă butonul Update.

Procedura se repetă pentru fiecare fişier care trebuie încărcat.

3.1.6 Browse
Aceasta este pagina în care se pot selecta fişierele care urmează a fi folosite în
proiect.

89
Figură 3.1.6 -1

După apăsarea oricărui buton Browse se va afişa o fereastră care permite selectarea
unui fişier pentru a fi utilizat în aplicaţie.

După ce fişierul a fost selectat se apasă butonul Select File.

3.1.7 Load Data


Aceasta este pagina în care se pot selecta fişierele care conţin datele pentru a fi
analizate în proiect.

Figură 3.1.7-1

90
Pentru a putea încărca datele in aplicaţie trebuie adăugat fişierul care le conţine.
Pentru acest lucru se apasă butonul Browse.

Acesta are ca efect ascunderea acestei ferestre şi afişarea unei alte ferestre care
permite selectarea fişierului.

Pentru mai multe detalii privind selecţia fişierelor a se vedea secţiunea 2.5.6 Browse.

După reapariţia ferestrei se va afişa numele fişierului, iar butonul Separator se va


activa

Următorul pas este alegerea separatorului de date.

Se alege separatorul din listă şi se apasă butonul Separator.

Figură 3.1.7-2

Acum se activează şi butonul Load Data şi se dezactivează Separator şi lista de


separatori.

Figură 3.1.7-3

După ce fişierul este gata pentru a fi uploadat în sistem se apasă butonul Load Data.

Dacă se doreşte analiza mai multor seturi de date procedura se repetă pentru fiecare
fişier care trebuie încărcat.

91
3.1.8 Grafice
Analiza şi afişarea graficelor se realizează în fereastra Series Analysis.

După ce a fost încărcat în sistem fişierul cu date se alege din meniul Analysis
submeniul Chart.

Se alege metoda de analiză din lista de metode disponibile şi graficul se va afişa


automat.

Figură 3.1.8-1

Dacă apar erori în aplicaţie în procesul de analiză sau/şi afişare a datelor se va afişa o
fereastră care vă va informa asupra acestui lucru precum şi cauza erorii.

Pentru mai multe detalii privind afişarea erori a se vedea secţiunea 2.5.11 Eroare.

3.1.9 User Manual


Accesarea meniului Help, submeniul User Manual va deschide o fereastră în care
poate fi vizualizat manualul de utilizare al aplicaţiei.

92
În partea superioară a ferestrei de află un slider care permite vizualizarea paginilor
din document.

Pentru a se ajunge la o anumită pagină se va trage cu mouse-ul de până se ajunge


în dreptul numărului pagini respective.

Pentru a se putea vizualiza şi informaţiile din partea inferioară a paginii se va utiliza


bara de defilare aflată în partea dreaptă a ferestrei.

Figură 3.1.9-1

3.1.10 About
Accesarea meniului Help, submeniul About va deschide o fereastră în care se pot
vizualiza câteva detalii despre această aplicaţie.

Figură 3.1.10-1

93
3.1.11 Eroare
Dacă apare o eroare în aplicaţie aceasta este semnalată către utilizator prin
intermediul unei ferestre.

Aceste erori pot fi:

- nu se poate genera graficul

- nu se poate citi fişierul cu date

- nu se pot citi fişierele cu istorice

- nu se poate citi fişierul cu metode

- nu se pot încărca fişiere pentru actualizare

Figură 3.1.11-1

94
3.2 NetBeans IDE 6.8

Primul program pe care l-am folosit pentru dezvoltarea aplicaţiei a fost


NetBeans IDE 6.8. Această aplicaţiei dezvoltată de firma SUN mi-a permis să creez
clasele şi ferestrele folosite în întreaga aplicaţie.

Figură 3.2-1

Pentru a folosi, a accesa aplicaţia se execută dublu click pe

iconiţa de pe desktop creată automat de program la instalare,

asemănătoare cu cea afişată în partea dreaptă.Aceasta va avea ca efect deschiderea


ferestrei principale:

Figură 3.2-2

95
În partea de sus a ferestrei (Figură 3.2-2) se află bara de meniuri.

Figură 3.2-3

Sub aceasta găsim o altă bară, cu instrumente care ne ajută să efectuăm anumite
operaţii fără a căuta comanda pentru acestea în bara de meniuri

Figură 3.2-4

În partea stângă a ferestrei se află un grup de ferestre care ne arată fişierele


deschise (clasele), pentru fiecare clasă ne indică atributele şi metodele existente,
conexiunea cu baza de date şi alte lucruri pe care noi dorim să le vizualizăm.
Deoarece putem modifica ferestrele pe care dorim să le vedem, putem alege să nu
vizualizăm nici una prin închiderea lor.

Pe partea dreaptă, reprezentâmd cea mai mare fereastră, este fereastra de lucru.
Aici se vor deschide ferestrele în care putem edita codul pentru fiecare clasă şi
crearea, prin intermediul unei interfeţe, a ferestrelor create de utilizatori pentru
dezvoltarea propriilor aplicaţii.

În partea de jos găsim un alt grup de ferestre pentru afişare: prima fereastră,
utilizată cel mai des, este cea pentru afişările din timpul rulării programului (afişări
impuse de utilizator, erori etc). Această fereastră poate fi închisă, însă se va deschide
automat la o nouă rulare a programului; dar pot fi deschise mai multe astfel de
ferestre în cazul unor rulări succesive, fără a închide sau a aştepta terminarea
execuţiei aplicaţiei.

A doua fereastră este fereastra pentru afişările din timpul rulării testelor JUnit
pentru ferestrele testate. Această fereastră are aceleaşi caracteristici ca şi precedenta.

Pentru a realiza o nouă aplicaţie se va selecta din meniul File opţiunea „New
Project...” şi va apărea fereastra de mai sus. Aceasta ne permite alegerea unui tip de
aplicaţie din mai multe categorii puse la dispoziţie. Cele mai folosite sunt categoriile
„Java” cu proiectul „Java Application” şi „Web” cu proiectul „Web Application”.

96
Figură 3.2-5

După ce am ales categoria si proiectul în care se încadrează aplicaţia noastră se


apasă pe butonul „Next >”.Efectul acestui buton va fi deschiderea ferestrei de mai
jos.

Aceasta ne permite să introducem numele proiectului precum şi locul pe disc


unde îl salvăm (Figură 3.1-6).

Figură 11-6

97
După ce am introdus aceste date se apasă pe „Finish”. Acum putem începe să
construim şi să implementăm clasele aplicaţiei.

Figură 3.2-7

Pentru a crea o nouă clasă, sau fereastră se apasă click-ul din dreapta al mouse-
lui pe pachetul creat cu numele dat de noi, se alege opţiunea „New”, iar apoi ceea ce
vrem să creem (Figură 3.1-8).

Figură 3.2-8

98
După ce am ales ce vrem să obţinem se va afişa o fereastră care ne cere să
introducem date legate de numele clasei (a ferestrei sau a ceea ce am ales pentru
creare) şi locaţia acesteia, după care se apasă pe butonul „Finish”.

Figură 3.2-9

Dacă am ales să obţinem ca rezultat o fereastră, o putem popula cu diferite


obiecte prin interfaţa pusă la dispoziţie de NetBeans: în partea dreaptă va apărea un
grup de ferestre suprapuse care ne oferă posibilitatea alegerii obiectelor (butoane,
câmpuri de text etc) cu un click şi punerea lor pe fereastra pe care dorim să o afişăm
la final, reprezentată de un chenar de culoare gri.

Figură 3.2-10

99
În cazul în care dorim să implementăm acţiunile unor obiecte alegem, din
partea superioară a ferestrei din centru, opţiunea „Source” şi vom
comuta pe „Design” doar dacă vrem să facem modificări asupra elementelor afişate
pe fereastră, fără a scrie noi codul sursă necesar.

Figură 3.2-11

După ce am creat clasele care compun


aplicaţia putem alege opţiunea realizării unui test
pentru fiecare clasă în vederea asigurării
corectitudinii implementării acesteia.

Pentru acest lucru se face click dreapta pe clasa


dorită să se testeze, se alege opţiunea „Tools”,iar
de aici „Create JUnit Tests” (Figură 3.1-12).

După ce am ales această opţiune se va afişa


o fereastră care ne oferă posibilitatea alegerii unor
opţiuni legate de modul de testare al clasei testate.

De cele mai multe ori aceste opţiuni sunt lăsate


bifate cum au apărut când s-a deschis fereastra
(rămân în modul „Default”). La final, fie că se fac
modificări, fie că nu, se apasă butonul „OK”
Figură 3.2-12
(Figură 3.1-13).

100
Figură 3.2-13

Efectul acestui buton este deschiderea ferestrei iniţiale (pentru realizarea


implementărilor), dar va avea în plus şi fereastra de test creată automat. În acest fel
putem implementa orice test de verificare dorim şi vizualizarea rezultatelor testului
(după compilare şi rulare).

Figură 3.2-14

101
Pentru închiderea aplicaţiei se apasă butonul aflat în colţul din dreapta sus
al ferestrei care defineşte spaţiul de afişare al programului NetBeans.

O altă posibilitate este accesarea meniului „File” şi de aici apăsăm pe opţiunea


„Exit”.

În ambele cazuri trebuie să salvăm tot ceea ce s-a lucrat până atunci. Dacă nu s-
a efectuat salvare până în acel moment se va afişa o fereastră de avertizare. Aceasta
ne oferă posibilitatea salvării, închiderii programului fără salvare sau întoarcerii la
fereastrele de lucru deschise anterior în cadrul proiectului.[16]

Figură 3.2-15

102
CONCLUZII

Analiza Seriilor reprezintă un proiect care nu se încheie odată cu susţinerea acestui


examen, ci el va continua să fie dezvoltat de viitorii masteranzi ai Universităţii Spiru
Haret care vor dori să studieze mai mult domeniul seriilor de timp.

Având ca principal scop o continuitate didactică, acest proiect va fi îmbunătăţit şi


actualizat cu noi modele şi metode de către studenţii universităţii.

În primul capitol sunt prezentate aspectele matematice care stau la baza acestui
program şi care pot sta, de asemenea, la baza dezvoltării ulterioare a unor noi metode
sau modele de analiză şi afişare grafică a seriilor de timp. Printre altele, aici sunt
prezentate două modele de extragere a trendului, precum şi câteva modele de serii de
timp – care pot reprezenta obiectul unui update ulterior al acestui program.

În al doilea capitol sunt prezentate fundamentele proiectării şi implementării acestui


proiect, precum şi explicitarea claselor constituente. Aici sunt prezentate trei şabloane
de proiectare care au contribuit la dezvoltarea aplicaţiei.

În ultimul capitol, capitolul trei, se regăseşte manualul de utilizare al aplicaţiei şi o


scurtă prezentare a programului în care am dezvoltat acest proiect. Acest capitol are
rolul de a facilita înţelegerea folosirii aplicaţiei, dar şi de a îndruma persoanele care
doresc continuarea acestui proiect pentru a dezvolta noile facilitati cat mai uşor în
clase Java prin intermediul programului Net Beans.

103
BIBLIOGRAFIE

1. Cooper J. The Design Patterns Java Companion [Carte]. - Reading :


Addison-Wesley, 1998.

2. Couch J., Seinberg, D. Java 2 Enterpise Edition Bible [Carte]. - New York :
Hungry Minds, 2002.

3. Eckstein R., Loy, M., Wood, D. Java Swing [Carte]. - Sebastopol : O'Reilly,
2001.

4. Frăsinaru C. Curs practic de Java [Carte].

5. Gallardo D. Java design patterns 101 [Carte].

6. LOOSE Project labs.cs.utt.rodocDPDP02.html. – Timişoara, 2008.

7. LOOSE Project labs.cs.utt.rodocDPDP10.html. – Timişoara, 2008.

8. Morrison M. Java 2 GUI Fundamentals with Swing [Carte]. - [s.l.] :


DigitalThink, 1999.

9. Reese G. Database Programming with JDBC and Java [Carte]. - Sebastopol :


O'Reily, 2001.

10. Richardson C., Avondolio, D., Schrager, S., Mitchell, M., Scanlon, J.
Professional Java JDK 6 Edition [Carte]. - Indianapolis : Wiley Publishing,
2007.

11. Robinson M., Vorobiev, P. Swing Second Edition [Carte]. - Greenwich :


Manning, 2003.

12. sim085 forum.java.sun.comforum.jspaforumID=57&start=0.mht. - 2005.

13. Tanasă Şt., Olaru, C., Andrei, Şt. Java de la 0 la expert [Carte]. - Iaşi :
Polirom, 2003.

14. Dumitru M. Comerţul Electronic – Lucrare de Licenţă – Piteşti, 2008.

15. www.sun.com NetBeans 6. - [s.l.] : Sun, 2008.

104
16. http://java.sun.com/docs/books/tutorial/uiswing/components/ Swing
elements – [s.l.] : Sun, 2010

17. Ruey S. Tsay Analysis of Financial Time Series – Canada : John Wilei &
Sons, Inc, 2002

18. www.csa-isc.ro

19. Voineagu V., Radu Şerban Teorie şi practică econometrică – Bucureşti :


Meteor Press, 2007

20. Pârţachi I Prognoza seriilor cronologice cu metode traditionale, econometrice


si modificarile lor – Bucureşti : ASE, 2003

21. Nicolescu O., Verboncu I. Metodologii manageriale – Bucureşti: Tribuna


Economică, 2001

22. Richard J. Povinelli Time series data mining: identifying temporal patterns
for characterization and prediction of time series events – Milwaukee:
Milwaukee, 1999

105