laboratorio di asd - i progetto

8/19/2019 Laboratorio Di ASD - I Progetto

1/35

Laboratorio di ASDPrimo progetto

a.a. 2006‐2007

Gabriele Savio ‐ Michele Di Cosmo


2/35

2

Indice

1. Introduzione ................................................. 3

2. Implementazione del programma di raccolta

e analisi dei dati .................................................... 3

2.1 Generazione di numeri casuali ............. 3

2.2 Input (classe) ........................................ 3

2.2.1 getTaraRip – Calcolo delle

ripetizioni della tara ...................................... 4

2.2.2 getTaraTime – Calcolo del tempo

medio della

tara

............................................

4

2.3 Algoritmi (classe astratta) ..................... 4

2.3.1 getRipLordo – Calcolo delle

ripetizioni lorde ............................................ 4

2.3.2 executeTest – Calcolo del tempo

lordo 5

2.4 Funzionamento generale (classe Tester)

5

2.4.1 getGranularita – Calcolo della

granularità ................................................. 5

2.4.2 Ciclo di test ................................... 5

2.5 Gerarchia .............................................. 7

2.6 Rilevazione dei tempi ........................... 8

2.7 Costanti ................................................. 8

3. Descrizione ed analisi degli algoritmi ........... 9

3.1 BubbleSort ............................................ 9

3.2 InsertionSort ......................................... 9

3.3 MergeSort ............................................ 9

3.4 QuickSort ............................................. 9

3.5 HeapSort ............................................ 10

4. Implementazione di SuperSort .................. 10

5. Tabelle ........................................................ 11

5.1 BubbleSort ......................................... 11

5.2 InsertionSort ...................................... 11

5.3 MergeSort .......................................... 12

5.4 QuickSort ........................................... 12

5.5 HeapSort ............................................ 13

5.6 SuperSort ........................................... 13

6. Grafici e discussione sui confronti della

complessità ........................................................ 14

6.1 BubbleSort vs. InsertionSort .............. 14

6.2 MergeSort vs. QuickSort .................... 14

6.3 InsertionSort vs. QuickSort vs.

SuperSort ....................................................... 15

6.3.1 QuickSort vs. SuperSort ............. 15

6.3.2 Zoom sull’intersezione ............... 16

6.4 MergeSort vs. QuickSort vs. HeapSort 16

7. Discussione dei risultati ottenuti ............... 17

8. Strumenti utilizzati ..................................... 17

9. Conclusioni ................................................. 18

Bibliografia ......................................................... 19


3/35

3

1. Introduzione

In questa analisi ci poniamo l’obiettivo di confrontare il comportamento di alcuni algoritmi di ordinamento

nel loro caso medio (con input casuale) in relazione alla teoria discussa nel corso.

E’ stato realizzato un programma in linguaggio Java atto a raccogliere i dati sperimentali ottenuti

eseguendo test per stimare il tempo di esecuzione degli algoritmi BubbleSort , InsertionSort , MergeSort ,

QuickSort e HeapSort su un vettore di numeri interi di lunghezza 100, 200, 500, 1000, 2000, 5000, 10000.

Per ogni algoritmo abbiamo calcolato il tempo medio di esecuzione su diverse dimensioni di input.

Basandoci poi sui risultati così ottenuti abbiamo elaborato un algoritmo denominato SuperSort che

ottimizza InsertionSort e QuickSort sfruttando il minor tempo di esecuzione del primo per input di

dimensione ridotta e quello del secondo per input di dimensione consistente.

I risultati sono stati eleborati e presentati qui in forma tabellare e grafica dando particolare risalto ai loro

andamenti asintotici.

Di seguito introduciamo l’implementazione del programma per la raccolta e l’analisi dei dati sperimentali.

2. Implementazione del programma di raccolta e analisi

dei

dati

2.1 Generazione di numeri casuali

Per la generazione dei numeri casuali abbiamo sfruttato la classe RandomGenerator fornita durante il

corso.

2.2 Input (classe)

L’input casuale è stato realizzato tramite la classe Input istanziabile con i parametri dimension, che

specifica la lunghezza dell’array, e rndGen, che rappresenta una istanza di RandomGenerator (adibita alla

generazione di numeri casuali).

Si noti che in questo modo la classe RandomGenerator viene istanziata un’unica volta all’avvio del

programma fornendo input diversi senza la necessità di modificare il seme su istanze diverse.


4/35

4

La classe Input fornisce i metodi copy, che restituisce un array int[ ] contenente una copia dell’input

rappresentato dalla classe, getTaraRip, che restituisce il numero di ripetizioni necessarie per calcolare il

tempo di tara e getTaraTime, che restituisce il tempo effettivo di tara.

2.2.1

getTaraRip

–

Calcolo

delle

ripetizioni

della

tara

Il metodo getTaraRip calcola, attraverso il codice analizzato durante il corso, il numero di ripetizioni

necessarie ad effettuare l’operazione copy sull’input, ovvero a copiare i dati su un vettore int[ ], in modo

che siano dell’ordine di grandezza che ci permetta di avere la precisione desiderata.

2.2.2 getTaraTime – Calcolo del tempo medio della tara

Il metodo getTaraTime calcola il tempo necessario a eseguire rip volte l’operazione copy sull’input, quindi

divide il tempo totale per il numero di ripetizioni (rip) restituendo il tempo medio dell’operazione copy.

2.3 Algoritmi (classe astratta)

L’implementazione degli algoritmi si è basata sullo pseudo‐codice elaborato durante il corso di Laboratorio.

Comunque, è stato necessario adattare lo pseudo‐codice al linguaggio Java. In particolare gli indici di

riferimento agli array sono stati modificati da 1‐based1 a 0‐based.

E’ stata realizzata una classe astratta Algoritmo dalla quale tutti gli algoritmi ereditano.

Algoritmo mette a disposizione i metodi getRipLordo per il calcolo delle ripetizioni lorde di un particolare

algoritmo,

execute per

l’esecuzione

unitaria

dell’algoritmo

ed

executeTest per

l’esecuzione

di

rip

volte

dell’algoritmo. In quest’ultimo caso viene restituito il tempo lordo per l’esecuzione unitaria dell’algoritmo

tramite execute con calcolato da getRipLordo. Algoritmo mette a disposizione alle classi che lo ereditano le operazioni comuni degli algoritmi: swap e

partition.

Gli algoritmi veri e propri (i.e. BubbleSort, MergeSort, ...) specificano obbligatoriamente i metodi execute

(int[ ] input ) per l’esecuzione dell’algoritmo.

2.3.1 getRipLordo – Calcolo delle ripetizioni lorde

Il metodo getRipLordo calcola il numero di ripetizioni necessarie ad eseguire l’operazione copy su Input e

execute su Algoritmo affinché siano dell’ordine di grandezza che ci permetta di avere la precisione

desiderata.

1 Per 1‐based si intende un vettore il cui indice iniziale è 1 (i.e. i vettori nella convenzione del pseudo‐codice).

Per 0‐based

un

vettore

con

indice

iniziale

0 (i.e.

i vettori

in

Java).


5/35

5

2.3.2 executeTest – Calcolo del tempo lordo

Il metodo executeTest esegue rip volte l’operazione copy su Input e execute su Algoritmo restituendo il

tempo medio per l’esecuzione delle due.

2.4

Funzionamento

generale

(classe

Tester)

La classe Tester è adibita a eseguire i test e presentare i risultati all’utente.

Vengono eseguite le seguenti operazioni di inizializzazione:

a)

Impostazione del vettore degli algoritmi e delle dimensioni su cui il test verrà eseguito e

istanziazione degli algoritmi

b)

Calcolo della granularità tramite il metodo getGranularita

c)

Calcolo di

tMin (vedi

2

) d)

Creazione di una istanza di RandomGenerator

e) Calcolo della tara per ogni dimensione di input tramite i metodi getTaraRip e getTaraTime di

Input

Terminate tutte le operazioni di inizializzazione viene eseguito il ciclo di test (vedi par. 2.4.2), adibito al

calcolo vero e proprio dei dati.

2.4.1 getGranularita – Calcolo della granularità

Per il calcolo della granularità utilizziamo lo pseudo‐codice visto durante il corso.

La granularità del sistema è la risoluzione dell’orologio di sistema e dipende dalle caratteristiche della

macchina e dal sistema operativo. Rappresenta la risoluzione del nostro sistema di misura.

2.4.2 Ciclo di test

Il ciclo di test è il cuore della raccolta e analisi dei dati sperimentali.

Inizialmente viene eseguito un ciclo sugli algoritmi da testare.

Successivamente viene eseguito un secondo ciclo annidato sulle dimensioni dei vettori di input.

Quindi si entra in un terzo ciclo annidato per eseguire totInput volte le ripetizioni con dimensione di input

fissa. All’interno di questo ciclo vengono eseguite le seguenti operazioni:

2 Dato che l’errore di misurazione scelto è 5% ( 0,05), bisogna misurare un tempo / che chiameremo · dove 1/. Nel nostro caso avremo 20.


6/35

6

a) Viene istanziata una classe Input contenente numeri casuali

b) Vengono calcolate le ripetizioni lorde tramite il metodo getRipLordo di Algoritmo

c) Viene eseguito l’algoritmo tramite il metodo executeTest di Algoritmo e calcolato tLordo

Per ogni

ciclo

sulla

dimensione

viene

calcolo

con TaraTime e TaraRip

calcolati in precedenza e ∆ 1 (vedi 3) usato per determinare l’intervallo di

confidenza.

3 0,05 quindi la funzione di distribuzione normale 1 1,96.

La

varianza

campionaria

è

invece

definita

come

∑ , .


7/35

7

2.5 Gerarchia

Fig. 1 ‐ Schema UML

Nota: Le frecce “uses” indicano che la

classe necessita di quella indicata per

poter funzionare. Le frecce normali

indicano eredità. Sono stati omessi i

parametri

delle

funzioni

per

sobrietà.


8/35

8

Tutti gli algoritmi ereditano dalla classe astratta Algoritmo.

Gli algoritmi, gli input e la classe RandomGenerator vengono istanziati direttamente dalla procedura main

di Tester.

Algoritmo necessita di Input, Input necessita di RandomGenerator e Tester necessita di tutte le classi.

2.6 Rilevazione dei tempi

La rilevazione dei tempi è stata effettuata tramite la funzione System.currentTimeMillis() che

restituisce la differenza, misurata in millisecondi, tra il tempo attuale e la mezzanotte del primo gennaio

1970 UTC.

Il tempo viene calcolato dalla funzione executeTest memorizzando l’istante in cui viene avviata

l’esecuzione di ripLordo istanze di input di dimensione uguale. Al termine dell’esecuzione viene sottratto il

tempo attuale a quello precedentemente memorizzato, quindi diviso per ripLordo. Il procedimento viene

ripetuto per totInput volte pari alla cardinalità del campione dei dati su input diversi, ma di stessa

dimensione. Il tempo totale viene sommato in tLordo, quindi diviso per totInput in modo da ottenere il

tempo lordo per l’esecuzione unitaria dell’algoritmo. Sottraendo il tempo medio della tara al tempo lordo si

ottiene tMedio.

La scelta di totInput è stata determinata dall’osservazione del variare dell’intervallo di confidenza con

diversi esperimenti. In conclusione un valore pari a 500 ci ha fornito una stima sufficientemente accurata.

E’ stato scelto di calcolare il numero di ripetizioni lorde necessarie per ottenere una stima accurata ogni

qualvolta venisse istanziato un nuovo input. Questo perché un input generato casualmente potrebbe venir

ordinato in un tempo inferiore a quello medio e pertanto rendere inaccurate tutte le rilevazioni effettuate

con quel numero di ripetizioni.

2.7 Costanti

Sono state

usate

le

seguenti

costanti:

Parametro Valore Descrizione

Seed 12345 Seme usato da RandomGenerator

totInput 500 Istanze del problema (campione dei dati)

tMinFatt 5 % Errore di misurazione minimo ammesso

5 % Esperimenti “cattivi” consentiti


9/35

9

3. Descrizione ed analisi degli algoritmi

3.1 BubbleSort

BubbleSort

opera

scambiando

ripetutamente

gli

elementi

adiacenti

che

non

sono

ordinati.

(Vedi

appendice)

E’ un algoritmo in‐place e ha complessità nel caso medio Θ.

3.2 InsertionSort

InsertionSort opera scandendo gli elementi del vettore e inserendoli uno ad uno creando una porzione

ordinata del vettore. (Vedi appendice)

E’ un algoritmo in‐place efficiente per ordinare un piccolo numero di elementi. Ha complessità nel caso

medio Ο.

3.3 MergeSort

MergeSort è un algoritmo divide et impera che si divide in tre passi: 1) divide l’array a metà; 2) ordina

ricorsivamente i due sotto‐array; 3) combina i due sotto‐array tramite un’operazione di Merge. (Vedi

appendice)

E’ un algoritmo non in‐place perché la procedura Merge fa uso di un vettore ausiliario. Ha complessità nel

caso medio

Θlog.

3.4 QuickSort

QuickSort è anch’esso un algoritmo divide et impera che si divide in due passi: 1) partiziona l’array tramite

la procedura Partition in due sotto‐array tali che ogni elemento del primo sia minore o uguale ad ogni

elemento del secondo; 2) ordina ricorsivamente i due sotto‐array. (Vedi appendice)

E’ un algoritmo in‐place con complessità nel caso medio Θlog.


10/35

10

3.5 HeapSort

HeapSort fa uso della struttura dati heap binario4. Opera trasformando l’array di input in una max‐heap

tramite la procedura Build-Max-Heap quindi isola la radice (elemento massimo) diminuendo la dimensione

della heap e ricostruisce la Max‐Heap fino a quando essa contiene un solo elemento. (Vedi appendice)

E’ un algoritmo in‐place perché la heap viene creata sul vettore stesso di input e i numeri ordinati viengono

scritti nella parte dell’array non utilizzata dalla heap. Ha complessità nel caso medio Θlog.

4. Implementazione di SuperSort

Per definire SuperSort abbiamo creato una variante ottimizzata di QuickSort che sfrutta la logica

dell’algoritmo InsertionSort quando la dimensione della porzione del vettore da ordinare è minore di una

costante 23 ottenuta analizzando sperimentalmente l’andamento di QuickSort e InsertionSort per un intorno di quelle dimensioni (Grafico 5). (Vedi appendice)

Sperimentalmente l’analisi dell’andamento di SuperSort mostra che questa ottimizzazione porta a risultati

migliori di QuickSort e InsertionSort (Grafico 5).

4 Un heap binario è un albero quasi‐completo (dove al più l’ultimo livello non è completo) in cui per ogni nodo , suo

figlio sinistro e suo figlio destro hanno se max‐heap, se min‐heap. Gli heap sono

facilmente

astraibili

con

un

array.


11/35

11

5. Tabelle

5.1 BubbleSort

Dimensione

(ms)

∆

100 0,04651132 0,00065345

200 0,19358528 0,00186868

500 1,22663323 0,00751779

1.000 4,88183009 0,02096474

2.000 19,33478251 0,06594697

5.000 120,68626697 0,24930691

10.000

488,23728590 0,80984848

Tabella 1 BubbleSort 5.2 InsertionSort

Dimensione (ms) ∆ 20 0,00090130 0,00005229

22 0,00117964 0,00006711

25 0,00211966 0,00009983

27

0,00283034

0,00010082

30 0,00338565 0,00011112

100 0,01692947 0,00067249

200 0,05232697 0,00133433

500 0,31523047 0,00361702

1.000 1,25857539 0,01010853

2.000 5,05570130 0,03253404

5.000

31,53726697

0,12220216

10.000 128,63578590 0,36066356

Tabella 2 InsertionSort


12/35

12

5.3 MergeSort

Dimensione (ms) ∆ 100 0,04783971 0,00064583

200

0,10019670

0,00128948

500 0,25924933 0,00319480

1.000 0,54040438 0,00632333

2.000 1,12835039 0,01340325

5.000 2,98157387 0,03350689

10.000 6,44205221 0,07194485

Tabella 3 MergeSort

5.4

QuickSort

Dimensione (ms) ∆ 20 0,00112556 0,00006559

22 0,00164684 0,00008800

25 0,00175486 0,00009401

27 0,00154499 0,00007430

30 0,00195073 0,00009638

100

0,00863412

0,00027761

200 0,02042939 0,00058420

500 0,09500950 0,00339026

1.000 0,23962539 0,00700631

2.000 0,51707368 0,01538605

5.000 1,19446648 0,04321511

10.000 2,36016754 0,08689184

Tabella 4 QuickSort


13/35

13

5.5 HeapSort

Dimensione (ms) ∆ 100 0,02144417 0,00043223

200

0,04872353

0,00089396

500 0,14086080 0,00233500

1.000 0,30641316 0,00475792

2.000 0,67663084 0,01033735

5.000 1,86855921 0,02666333

10.000 4,05616864 0,05613868

Tabella 5 HeapSort

5.6

SuperSort

Dimensione (ms) ∆ 20 0,00089380 0,00004988

22 0,00103655 0,00005460

25 0,00119389 0,00005965

27 0,00130817 0,00006661

30 0,00151031 0,00007182

100

0,00736295

0,00026318

200 0,01761005 0,00053509

500 0,05261323 0,00141684

1.000 0,11814652 0,00301975

2.000 0,26202100 0,00643948

5.000 0,73965388 0,01674467

10.000 1,66480147 0,04378098

Tabella 6 SuperSort


14/35

14

6. Grafici e discussione sui confronti della complessità

6.1 BubbleSort vs. InsertionSort

Grafico 1 BubbleSort vs. InsertionSort

Errore asintotico standard % err.BubbleSortTrend 4,87907 · 10 5,320 · 10 0,10900 % InsertionSortTrend 1,28486 · 10 2,412 · 10 0,18770 %

6.2

MergeSort

vs.

QuickSort

Grafico 2 MergeSort vs. QuickSort

Errore asintotico standard % err.MergeSortTrend 4,85910 · 10 · log 2,742 · 10 0,56420 % QuickSortTrend 1,82076 · 10 · log 4,498 · 10 2,47000 %

0

100

200

300

400

500

600

100 200 500 1000 2000 5000 10000

t M e d i o ( m s )

Dimensione dell'input

BubbleSort

InsertionSort

BubbleSortTrend

InsertionSortTrend

0

1

2

3

4

5

6

7

100 200 500 1000 2000 5000 10000

t M e d i o ( m s )


MergeSort

QuickSort

MergeSortTrend

QuickSortTrend


15/35

15

6.3 InsertionSort vs. QuickSort vs. SuperSort

Grafico 3 InsertionSort vs. QuickSort vs. SuperSort

Errore asintotico standard % err.InsertionSortTrend 1,28486 · 10 2,412 · 10 0,18770 % QuickSortTrend 1,82076 · 10 · log 4,498 · 10 2,47000 % SuperSortTrend 1,24282 · 10 · log 8,284 · 10 0,66650 %

6.3.1

QuickSort

vs.

SuperSort

Grafico 4 QuickSort vs. SuperSort

0

20

40

60

80

100

120

140

100 200 500 1000 2000 5000 10000

t M e d i o ( m s )


InsertionSort

QuickSort

SuperSort

InsertionSortTrend

QuickSortTrend

SuperSortTrend

0,0

0,5

1,0

1,5

2,0

2,5

3,0

100 200 500 1000 2000 5000 10000

t M e d i o ( m s )


QuickSort

SuperSort

QuickSortTrend

SuperSortTrend


16/35

16

6.3.2 Zoom sull’intersezione

Grafico 5 Zoom di InsertionSort vs. QuickSort vs. SuperSort

6.4 MergeSort vs. QuickSort vs. HeapSort

Grafico 6 MergeSort vs. QuickSort vs. HeapSort

Errore asintotico standard % err.MergeSortTrend 4,85910 · 10 · log 2,742 · 10 0,56420 % QuickSortTrend 1,82076 · 10 · log 4,498 · 10 2,47000 % HeapSortTrend 3,05156 · 10 · log 3,051 · 10 0,09998 %

0,0000

0,0005

0,0010

0,0015

0,0020

0,0025

0,0030

0,0035

0,0040

20 22 25 27 30

t M e d i o ( m s )


InsertionSort

QuickSort

SuperSort

0

1

2

3

4

5

6

7

100 200 500 1000 2000 5000 10000

t M e d i o ( m

s )


MergeSort

QuickSort

HeapSort

MergeSortTrend

QuickSortTrend

HeapSortTrend


17/35

17

7. Discussione dei risultati ottenuti

Di seguito esponiamo le nostre analisi.

Dal

Grafico

1

possiamo

confrontare

l’andamento

dei

due

algoritmi

di

complessità

quadratica:

BubbleSort

e

InsertionSort.

Notiamo

che

BubbleSort

impiega

notevolmente

più

tempo

a

ordinare

input

di

grandi

dimensioni rispetto a InsertionSort; peraltro questo comportamento era ampiamente previsto dagli studi

teorici

dato

che

l’algoritmo

BubbleSort

esegue

sempre

e

comunque

confronti.

Al

contrario,

InsertionSort

esegue solo confronti in caso di elementi già ordinati.

Dal

Grafico

2

e

dal

Grafico

6

possiamo

osservare

con

attenzione

l’andamento

dei

tre

algoritmi

di

complessità Θ log . Gli studi teorici non avevano messo in risalto le costanti moltiplicative di tali

algoritmi,

precludondoci

la

possibilità

di

analizzare

quale

fosse

effettivamente

il

più

efficiente.

Dai dati osserviamo che MergeSort risulta il “più lento” fra i tre analizzati, nel senso che richiede più

elaborazione per ordinare vettori di grandi dimensioni.

Al contrario QuickSort si pone come la migliore scelta tra i tre ordinando in un tempo minore sia di

MergeSort che di HeapSort.

Dopo esserci posti il problema di dover creare un algoritmo che avesse una costante moltiplicativa migliore

rispetto

agli

altri

algoritmi

studiati,

abbiamo

deciso

di

usare

i

due

algoritmi

che

su

dimensioni

differenti

si

comportavano meglio: InsertionSort su piccole dimensioni e QuickSort su grandi dimensioni (Grafico 5).

Abbiamo

quindi

creato

SuperSort:

una

variante

di

QuickSort

che

richiama

al

suo

interno

InsertionSort

quando QuickSort si trova a trattare input di dimensione minore di 23 (con ottenuto empiricamente

osservando il Grafico 5) (vedasi paragrafo 4, pag. 10). Quindi abbiamo analizzato il comportamento di

quest’ultimo

che,

in

relazione

a

QuickSort

e

agli

altri

algoritmi,

risulta

esser

migliore

(vedasi

paragrafo

6.3.1).

8.

Strumenti

utilizzati

Per l’esecuzione del programma di raccolta e analisi dei dati sperimentali è stato utilizzato un calcolatore

con processore Intel Pentium 4 con una frequenza di 3,00 GHz e 1,00 GB di RAM. La macchina è stata


18/35

18

eseguita su una clean‐install5 del sistema operativo è Windows XP Home Edition con Service Pack 2 su cui

sono stati installati J2SDK 1.4.2.13, JavaSE‐RE 6 e BlueJ 2.1.3.

Per la post‐elaborazione dei dati sono stati usati Microsoft Excel 2007.

Le funzioni interpolanti sono state ottenute con il metodo fit di gnuPlot 4.2.0 compilato su piattaforma

win32. Tale metodo utilizza un’implementazione dell’algoritmo NLLS (“nonlinear lest‐squares Marquardt‐

Levenberg algorithm”).

Per la presentazione dei dati sono stati usati Microsoft Word 2007 e Microsoft Visio 2007.

9. Conclusioni

In conclusione possiamo dire che lo studio sperimentale degli algoritmi basati su confronto studiati durante

il corso, ci ha permesso di confrontarci con molte problematiche sull’implementazione degli algoritmi, sulla

rilevazione dei tempi infinitesimali del calcolatore e su una realizzazione gerarchica flessibile del codice.

Inoltre, queste problematiche ci hanno aiutato a comprendere il valore di una buona analisi statistica, come

ad esempio la scelta di un buon campione di esperimenti.

Abbiamo compreso l’importanza di escegliere un buon algoritmo adeguato alle proprie esigenze e di

migliorarlo in

base

alla

situazione

specifica.

Concludendo possiamo affermare che le analisi sperimentali si sono rivelate complementari e necessarie

agli studi teorici.

5

Per

clean

‐install

si

intende

un

sistema

operativo

appena

installato

senza

applicativi

addizionali.


19/35

19

Bibliografia

‐ Introduzione agli algoritmi e strutture dati (T. H. Cormin, C. E. Leiserson, R. L. Rivest, C. Stein)

McGraw‐Hill – 2° edizione

‐ Java

–

fondamenti

di

progettazione

software

(J.

Lewis,

W.

Loftus)

Addison

‐Wesley

–

1°

edizione

‐ Dispense del corso di Laboratorio di algoritmi e strutture dati (S. Scalabrin) 2007

‐ Appunti del corso di Algoritmi e strutture dati


20/35

1 / ** Quest a cl asse cont i ene i l codi ce per esegui r e i t est sugl i al gor i t mi2 * e present are al l ' ut ent e i r i sul t at i3 *4 *5 * @aut hor ( G. Savi o, M. Di Cosmo)6 * @ver si on ( 23/ 04/ 2007 - 23. 48)7 * /89 publ i c c l ass Test er

10 {

11 publ i c st at i c f i nal i nt seed = 12345; / / Seme per l a generazi one di vet t ori connumer i casual i12 publ i c st at i c f i nal i nt t ot I nput = 500; / / Numer o di vol t e che l ' al gor i t mo vi ene

esegui t o su un dat o i nput13 publ i c st at i c f i nal i nt t Mi nFat t = 5; / / % Er r or e ammesso14 publ i c st at i c f i nal doubl e del t aConst = 1. 96; / / Cost ant e di del t a, vedi t abel l a.15 publ i c st at i c i nt [ ] i nput Di mensi on; / / Di mensi one degl i i nput16 publ i c st at i c i nt [ ] i nput Tar aRi p; / / N° di r i pet i z i oni del l a t ar a per una

det ermi nat a di mensi one di i nput17 publ i c st at i c l ong[ ] i nput Tar aTi me; / / Tempo del l a t ara per una det ermi nat a

di mensi one di i nput18 publ i c st at i c l ong granul ar i t a; / / Granul ar i t à19 publ i c st at i c l ong t Mi n; / / t Mi n20 publ i c st at i c Al gori t mo al gor i t mi [ ] ; / / Ar r ay di al gor i t mi su cui ver r à esegui t o

i l t est

21 publ i c st at i c RandomGener at or r ndGen;22 23 publ i c st at i c voi d mai n( St r i ng[ ] a rgs ){24 mai n( ) ;25 }26 27 publ i c st at i c voi d mai n( ) {28 29 l ong st ar t Ti me = Syst em. cur rent Ti meMi l l i s ( ) ;30 31 Syst em. out . pr i nt l n ( " " ) ;32 Syst em. out . pr i nt l n ( " >" ) ;33 34 / ** Modi f i care l e seguent i i mpostaz i oni per ot t enere i r i sul t at i vol ut i ** /35

36 / / I mpost o l e di mensi oni degl i i nput37 i nput Di mensi on = new i nt [ 7 ] ;38 i nput Di mensi on[ 0] = 100;39 i nput Di mensi on[ 1] = 200;40 i nput Di mensi on[ 2] = 500;41 i nput Di mensi on[ 3] = 1000;42 i nput Di mensi on[ 4] = 2000;43 i nput Di mensi on[ 5] = 5000;44 i nput Di mensi on[ 6] = 10000;4546 / / I mpost o gl i al gor i t mi47 al gori t mi = new Al gori t mo[ 6 ] ;48 al gor i t mi [ 0] = new Super Sor t ( ) ;49 al gor i t mi [ 1] = new Qui ckSor t ( ) ;50 al gor i t mi [ 2] = new HeapSor t ( ) ;

51 al gor i t mi [ 3] = new Mer geSor t ( ) ;52 al gor i t mi [ 4] = new I nser t i onSor t ( ) ;53 al gor i t mi [ 5] = new Bubbl eSor t ( ) ;54 55 / ** Fi ne sezi one i mpost azi oni ut ent e **/56 57 / * * I ni t * */58 / / Cal col o l a granul ar i t à59 gr anul ar i t a = get Gr anul ar i t a( ) ;60 Syst em. out . pr i nt l n ( "% Gr anul ari t à = " + gr anul ari t a);61 62 / / Cal col o t Mi n63 l ong t Mi nGr anCoef f = ( l ong) ( ( f l oat ) 1 / ( ( f l oat ) t Mi nFat t / ( f l oat ) 100) ) ;64 t Mi n = gr anul ari t a * t Mi nGr anCoef f ;65 Syst em. out . pr i nt l n ( " % Er r or e ammess o = " + t Mi nFat t + " %" ) ;

66 Syst em. out . pr i nt l n ( "% t Mi n = " + t Mi n + " ( granul ar i t à * " + t Mi nGr anCoef f +" )" ) ;

67 Syst em. out . pr i nt l n ( "% Cost ant e di del t a = " + del t aConst ) ;68 69 r ndGen = new RandomGener at or ( seed) ;

20


21/35

70 Syst em. out . pr i nt l n ( " % Seme = " + seed) ;71 72 Syst em. out . pr i nt l n ( "% Ri pet i z i one degl i al gor i t mi su i nput di ver si = " +

t ot I nput ) ;73 74 / / Scr i vo l e di mensi oni75 Syst em. out . pr i nt ( " % Di mensi oni =" ) ;76 f or ( i nt i = 0; i < i nput Di mensi on. l engt h; i ++) {77 Syst em. out . pr i nt ( " " + i nput Di mensi on[ i ] ) ;78 }

79 Syst em. out . pr i nt l n ( " " ) ;80 81 / / Sc r i vo gl i al gor i t mi82 Syst em. out . pr i nt ( "% Al gor i t mi =" ) ;83 f or ( i nt i = 0; i < al gor i t mi . l engt h; i ++) {84 Syst em. out . pr i nt ( " " + al gor i t mi [ i ] . get Name( ) ) ;85 }86 Syst em. out . pr i nt l n ( " " ) ;87 88 / ** Tar a **/89 / / Cal col o l a t ara degl i i nput90 i nput Tar aRi p = new i nt [ i nput Di mensi on. l engt h] ;91 i nput TaraTi me = new l ong[ i nput Di mensi on. l engt h] ;92 f or ( i nt i = 0; i < i nput Di mensi on. l engt h; i ++) {93 Syst em. out . pr i nt ( "Cal col o del l a t ar a per l a di mensi one " + i nput Di mensi on

[ i ] + " . . . " ) ;94 95 I nput i nput = new I nput ( r ndGen, i nput Di mensi on[ i ] ) ;96 97 i nput Tar aRi p[ i ] = i nput . get Tar aRi p( t Mi n) ;98 Syst em. out . pr i nt ( " r i p=" + i nput Tar aRi p[ i ] ) ;99

100 i nput Tar aTi me[ i ] = i nput . get TaraTi me( i nput TaraRi p[ i ] ) ;101 Syst em. out . pr i nt l n ( " t i me=" + i nput Tar aTi me[i ] ) ;102 103 }104 105 Syst em. out . pr i nt l n ( " " ) ;106 Syst em. out . pr i nt l n ( "* Tabel l a tara") ;107 Syst em. out . pr i nt l n ( " i dx\ t di m\ t t ar aRi p\ t t ar aTi me" ) ;

108 f or ( i nt i = 0; i < i nput Di mensi on. l engt h; i ++) {109 Syst em. out . pr i nt l n ( i + " \ t " + i nputDi mensi on[ i ] + " \ t " + i nput Tar aRi p[ i ] +

" \ t " + i nput Tar aTi me[ i ] ) ;110 }111 112 / ** Al gor i t mi ** /113 Syst em. out . pr i nt l n ( " " ) ;114 Syst em. out . pr i nt l n ( "* Tabel l a esecuzi one al gor i t mi " ) ;115 Syst em. out . pr i nt l n ( " i dxAl g\ t i dxDi m\ t Al g. \ t Di m. \ t 1°r i pLor do\ t t Lor do\ t t Lor do 2̂\

t t Medi o\ t Del t a\ t Ti me" ) ;116 f or ( i nt al g = 0; al g < al gori t mi . l engt h; al g++) {117 / ** Di mensi oni **/118 f or ( i nt di m = 0; di m < i nput Di mensi on. l engt h; di m++) {119 120 Syst em. out . pr i nt ( al g) ;

121 Syst em. out . pr i nt ( " \ t " + di m) ;122 Syst em. out . pr i nt ( " \ t " + al gori t mi [ al g] . get Name( ) ) ;123 Syst em. out . pr i nt ( " \ t " + i nputDi mensi on[ di m] ) ;124 125 / / I st anzi o e azzer o t Lor do126 doubl e t Lor do = 0;127 doubl e t Lor doQuadr at o = 0;128 129 l ong t ot I nput Ti me = Syst em. cur r ent Ti meMi l l i s ( ) ;130 131 / ** I nput di ver s i esegui t i r i pLor do vol t e ** /132 f or ( i nt nI nput = 0; nI nput < t ot I nput ; nI nput ++) {133 134 / / Gener o l ' i nput135 I nput i nput = new I nput ( r ndGen, i nputDi mensi on[ di m] ) ;

136 137 / / Cal col o r i pLordo138 i nt r i pLor do = al gor i t mi [ al g] . get Ri pLor do( t Mi n, i nput ) ;139 140 i f ( nI nput == 0) {

21


22/35

141 Syst em. out . pr i nt ( " \ t " + r i pLor do);142 }143 144 / / Aggi ungo i l t empo l ordo i mpi egato a t Lor do145 doubl e t Al g = al gor i t mi [ al g] . execut eTest ( i nput , r i pLor do) ;146 t Lor do = t Lor do + t Al g;147 t LordoQuadr at o = t LordoQuadr at o + ( t Al g * t Al g) ;148 149 }150 t Lor do = t Lor do / t ot I nput ;

151 t LordoQuadr at o = t LordoQuadr at o / t ot I nput ;152 Syst em. out . pr i nt ( " \ t " + t Lordo) ;153 154 Syst em. out . pr i nt ( " \ t " + t Lor doQuadrat o) ;155 156 / / t Medi o157 doubl e t Medi o = ( t Lor do - ( ( doubl e) i nput Tar aTi me[ di m] / ( doubl e)

i nput Tar aRi p[ di m] ) ) ;158 Syst em. out . pr i nt ( " \ t " + t Medi o) ;159 160 / / Del t a161 doubl e Del t a = ( 1 / Mat h. sqr t ( t ot I nput ) * del t aConst * ( Mat h. s qr t

( t Lor doQuadr ato - ( t Medi o * t Medi o)) ) ) ;162 Syst em. out . pr i nt ( " \ t " + Del t a) ;163

164 Syst em. cur r ent Ti meMi l l i s ( ) ;165 Syst em. out . pr i nt ( " \ t " + ( Syst em. cur r ent Ti meMi l l i s ( ) - t ot I nput Ti me) ) ;166 167 Syst em. out . pr i nt l n ( " " ) ;168 169 }170 }171 172 / / Fi ne173 Syst em. out . pr i nt l n ( " " ) ;174 Syst em. out . pr i nt l n ( " < Ter mi nat o ( " + ( Syst em. cur r ent Ti meMi l l i s ( ) - s t ar t Ti me)

+ " ms" ) ;175 176 }177

178 publ i c st at i c voi d Test ( i nt seed) {179 180 Syst em. out . pr i nt l n ( " " ) ;181 Syst em. out . pr i nt l n ( "Test s t art ed wi t h seed " + seed) ;182 183 r ndGen = new RandomGener at or ( seed) ;184 185 I nput i nput = new I nput ( r ndGen, 1000) ;186 i nt [ ] vect = i nput . copy() ;187 188 Syst em. out . pr i nt ( "bef or e: " ) ;189 dumpVect ( vect ) ;190 191 Al gori t mo al g = new Qui ckSor t ( ) ;192 Syst em. out . pr i nt ( " execut i ng " + al g. getName( ) + " . . . " ) ;

193 194 l ong t 0 = Syst em. cur rent Ti meMi l l i s ( ) ;195 al g. execut e( vect ) ;196 l ong t 1 = Syst em. cur rent Ti meMi l l i s ( ) ;197 Syst em. out . pr i nt l n ( " done i n " + ( t 1- t 0) + " ms" ) ;198 199 Syst em. out . pr i nt ( " a f t e r : " ) ;200 dumpVect ( vect ) ;201 202 Syst em. out . pr i nt l n ( "Checki ng vect or . . . " ) ;203 i nt val ue = vect [ 0] ;204 f or ( i nt i = 0; i < vect . l engt h; i ++) {205 i f ( val ue > vect [ i ] ) {206 Syst em. out . pr i nt l n ( " ! ERROR ! @" + i ) ;207 re turn;

208 }el se{209 val ue = vect [ i ] ;210 }211 }212

22


23/35

213 Syst em. out . pr i nt l n ( " Test ended") ;214 Syst em. out . pr i nt l n ( " " ) ;215 }216 217 publ i c st at i c l ong get Gr anul ar i t a( ) {218 / / Cal col a l a granul ar i t à219 220 l ong t 0 = Syst em. cur rent Ti meMi l l i s ( ) ;221 l ong t 1 = Syst em. cur rent Ti meMi l l i s ( ) ;222

223 whi l e ( t 0 == t 1) {224 t 1=Syst em. cur r ent Ti meMi l l i s ( ) ;225 }226 227 re turn ( t 1 - t 0 ) ;228 229 }230 231 pr i vat e s t at i c voi d dumpVect ( i nt [ ] vec t ){232 Syst em. out . pr i nt ( " VECT: [ " + vect . l ength + " ] " ) ;233 f or ( i nt i = 0; i < vect . l engt h; i ++) {234 Syst em. out . pr i nt ( " " + vect[ i ] ) ;235 }236 Syst em. out . pr i nt l n ( " " ) ;237 }

238 239 }240

23


24/35

1 / **2 * Quest a cl asse ast r att a i mpl ement a l e f unzi oni di base di un al gori t mo3 * per i l t e st4 *5 * @aut hor ( G. Savi o, M. Di Cosmo)6 * @ver si on ( 23/ 04/ 2007 - 23. 48)7 * /89 publ i c abst r act c l ass Al gori t mo

10 {

11 12 publ i c st at i c f i nal i nt ci c l i Er r at i = 5;13 14 publ i c abst r act St r i ng get Name( ) ;1516 / / I mpl ement a l ' esecuzi one ver a e pr opr i a del l ' al gor i t mo17 publ i c abst r act voi d execut e( i nt [ ] i nput ) ;18 19 publ i c doubl e execut eTest ( I nput i nput , i nt r i p) {20 / / Esegue l ' al gor i t mo sul l ' i nput passat o r i p vol t e21 / / Vi ene rest i t ui t o t Lordo22 23 doubl e t 0 = Syst em. cur r ent Ti meMi l l i s ( ) ;24 25 f or ( i nt i = 0; i < r i p; i ++) {

26 / / Syst em. out . pr i nt l n ( "esecuzi one " + i + " / " + r i p) ;27 execut e( i nput . copy( ) ) ;28 }29 30 doubl e t 1 = Syst em. cur r ent Ti meMi l l i s ( ) ;31 / / Syst em. out . pr i nt l n ( " Tempo su un ci cl o r i p da " + r i p + ": " + ( t 1 - t 0) + "ms") ;32 33 return ( t 1 - t 0) / r i p;34 35 }36 37 publ i c i nt get Ri pLor do( l ong t Mi n, I nput i nput ) {38 / / Cal col a r i pLor do per questo al gor i t mo39 40 l ong t 0 = 0;

41 l ong t 1 = 0;42 i nt r i p = 1;43 i nt [ ] vect = i nput . copy() ;44 45 whi l e ( t 1 - t 0


25/35

76 }77 78 return max;79 80 }81 82 pr ot ect ed st at i c voi d swap( i nt [ ] vet t , i nt i , i nt j ) {83 / / Scambi a l ' el ement o i con j nel vet t or e vet t84 i nt t emp=vet t [ i ] ;85 vet t [ i ] =vet t [ j ] ;

86 vet t [ j ] =t emp;87 }88 89 pr ot ect ed st at i c i nt par t i t i on( i nt [ ] vet t , i nt p, i nt r ) {90 / / Esegue l a procedura par t i t i on sul vet t ore vet t dal l ' i ndi ce p al l ' i ndi ce r91 i nt x = vet t [ r ] ;92 i nt i = p - 1;93 f or ( i nt j = p; j < r ; j ++) {94 i f ( vet t [ j ]


26/35

1 / **2 * I mpl ement a l ' al gor i t mo Bubbl eSort3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass Bubbl eSor t ext ends Al gori t mo9 {

10

11 publ i c St r i ng get Name( ) {12 return "Bubbl eSort " ;13 }1415 publ i c voi d execut e ( i nt [ ] i nput ) {16 17 i nt n = i nput . l engt h - 1;18 19 f or ( i nt j = n; j > 0; j - - ) {20 f or ( i nt i = 0; i < j ; i ++) {21 i f ( i nput [ i ] > i nput [ i +1 ] ){22 swap( i nput , i , i +1) ;23 }24 }25 }

26 27 }2829 }30

26


27/35

1 / **2 * I mpl ement a l ' al gor i t mo Mer geSort3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass Mer geSor t ext ends Al gor i t mo9 {

10

11 publ i c St r i ng get Name( ) {12 return " Mer geSor t " ;13 }1415 publ i c voi d execut e( i nt [ ] i nput ) {16 execut e( i nput , 0, i nput . l engt h - 1) ;17 }18 19 publ i c voi d execut e( i nt [ ] i nput , i nt p, i nt r ) {20 i f ( p < r ) {21 i nt q = ( i nt ) Mat h. f l oor ( ( p + r ) / 2) ;22 execut e( i nput , p, q) ;23 execut e( i nput , q+1, r ) ;24 Mer ge( i nput , p, q, r ) ;25 }

26 }27 28 pr i vat e voi d Mer ge( i nt [ ] vet t , i nt p, i nt q, i nt r ) {29 i nt i = p;30 i nt j = q + 1;31 i nt [ ] t empvet t = new i nt [ r - p + 1] ;3233 f or ( i nt k = 0; k < r - p + 1; k++) {34 i f ( ( i


28/35

1 / **2 * I mpl ement a l ' al gor i t mo I nsert i onSor t3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass I nser t i onSor t ext ends Al gori t mo9 {

10

11 publ i c St r i ng get Name( ) {12 return " I nser t i onSor t " ;13 }1415 publ i c voi d execut e ( i nt [ ] i nput ) {16 17 i nt n = i nput . l engt h;18 19 f or ( i nt j = 1; j < n; j ++) {20 i nt t emp = i nput [ j ] ;21 i nt i = j - 1;22 whi l e ( ( i >= 0) && ( i nput [ i ] > t emp) ) {23 i nput [ i + 1] = i nput [ i ] ;24 i - - ;25 }

26 i nput [ i + 1] = t emp;27 }28 29 }3031 }

28


29/35

1 / **2 * I mpl ement a l ' al gor i t mo HeapSor t3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass HeapSor t ext ends Al gori t mo9 {

10

11 pr i vat e i nt heapsi ze = 0;1213 publ i c St r i ng get Name( ) {14 return " HeapSor t " ;15 }1617 publ i c voi d execut e( i nt [ ] i nput ) {18 bui l dHeap( i nput ) ;19 f or ( i nt i = i nput . l engt h - 1; i > 0; i - - ) {20 swap( i nput , 0, i ) ;21 heapsi ze- - ;22 heapi f y( i nput , 0) ;23 }24 }25

26 pr i vat e i nt l ef t ( i nt i ) {return 2* i ; }27 pr i vat e i nt r i ght ( i nt i ) {return 2* i +1; }28 pr i vat e i nt par ent ( i nt i ) {return ( i nt ) Mat h. f l oor ( i / 2) ; }29 30 pr i vat e voi d bui l dHeap( i nt [ ] v e t t ) {31 heapsi ze = vet t . l engt h - 1;32 f or ( i nt i = ( i nt ) Mat h. f l oor ( ( v et t . l engt h - 1) / 2) ; i >= 0; i - - ) {33 heapi f y( v et t , i ) ;34 }35 }36 37 pr i vat e voi d heapi f y( i nt [ ] vet t , i nt i ) {38 i nt max;39 i nt l = l ef t ( i ) ;40 i nt r = r i ght ( i ) ;

41 i f ( ( l vet t [ i ] ) ) {42 max = l ;43 }el s e{44 max = i ;45 }46 i f ( ( r = vet t [ max] ) ) {47 max = r ;48 }49 i f ( max ! = i ) {50 swap( vet t , i , max);51 heapi f y(vet t , max);52 }53 }54 55 }

29


30/35

1 / **2 * I mpl ement a l ' al gor i t mo Mer geSort3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass Qui ckSor t ext ends Al gor i t mo9 {

10

11 publ i c St r i ng get Name( ) {12 return "Qui ckSort " ;13 }1415 publ i c voi d execut e( i nt [ ] i nput ) {16 execut e( i nput , 0, i nput . l engt h - 1) ;17 }18 19 publ i c voi d execut e( i nt [ ] i nput , i nt p, i nt r ) {20 i f ( p < r ) {21 i nt q = par t i t i on ( i nput , p, r ) ;22 execut e( i nput , p, q- 1) ;23 execut e( i nput , q + 1, r ) ;24 }25 }

26 27 }

30


31/35

1 / **2 * I mpl ement a l ' al gor i t mo Super Sor t3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass Super Sor t ext ends Al gor i t mo9 {

10

11 publ i c st at i c f i nal i nt k = 23;1213 publ i c St r i ng get Name( ) {14 return "SuperSor t " ;15 }16 17 publ i c voi d execut e( i nt [ ] i nput ) {18 execut e( i nput , 0, i nput . l engt h - 1) ;19 }20 21 publ i c voi d execut e( i nt [ ] i nput , i nt p, i nt r ) {22 i f ( r - p t emp) ) {38 i nput [ i + 1] = i nput [ i ] ;39 i - - ;40 }

41 i nput [ i + 1] = t emp;42 }43 }44 45 }

31


32/35

1 / **2 * Rappr esent azi one di un i nput vet t or i al e3 *4 * @aut hor ( G. Savi o, M. Di Cosmo)5 * @ver si on ( 23/ 04/ 2007 - 23. 48)6 * /78 publ i c c l ass I nput9 {

10

11 publ i c st at i c f i nal i nt ci c l i Er r at i = 5;12 pr i vat e RandomGener at or r ndGen;1314 pr i vat e i nt [ ] i nput Vector ;1516 publ i c I nput ( RandomGener at or r ndGen, i nt di mensi on) {17 / / Cr ea un ar r ay di di mensi one di mensi on18 t hi s. r ndGen = r ndGen;19 i nput Vect or = new i nt [ di mensi on] ;20 popul at e( ) ;21 }22 23 pr i vat e voi d popul at e( ) {24 / / Popol a l ' ar r ay con val or i casual i25 f or ( i nt i = 0; i < i nput Vect or. l engt h; i ++) {

26 i nput Vect or [ i ] = ( i nt ) Mat h. r ound ( r ndGen. get( ) * i nput Vect or . l engt h) ;27 }28 }29 30 publ i c i nt [ ] copy( ){31 / / Rest i t ui sce un i nput i n format o i nt [ ] dupl i cat o da quel l o rappr esent at o

dal l a c l asse32 i nt [ ] ret = new i nt [ i nput Vector . l engt h] ;33 f or ( i nt i = 0; i < i nput Vect or. l engt h; i ++) {34 re t [ i ] = i nput Vec tor [ i ] ;35 }36 return r e t ;37 }38 39 publ i c l ong get TaraTi me( i nt tareRi p) {

40 / / Rest i t ui sce i l t empo di t ar a per quest o i nput41 42 l ong t 0 = Syst em. cur r ent Ti meMi l l i s ( ) ;43 44 f or ( i nt i = 0; i < t ar eRi p; i ++) {45 copy() ;46 }47 48 l ong t 1 = Syst em. cur r ent Ti meMi l l i s ( ) ;49 50 return ( t 1 - t 0 ) ;51 }52 53 publ i c i nt get Tar aRi p( l ong t Mi n) {54 / / Rest i t ui sce l e r i pet i z i oni mi ni me per l a t ara

55 56 l ong t 0 = 0;57 l ong t 1 = 0;58 59 i nt r i p = 1;60 61 whi l e ( t 1 - t 0


33/35

75 i nt mi n = r i p / 2;76 77 whi l e ( max - mi n >= ci cl i Er r at i ) {78 79 r i p = ( max + mi n) / 2;80 t 0 = Syst em. cur r ent Ti meMi l l i s ( ) ;81 82 f or ( i nt i = 1; i


34/35

1 / /2 / / Cl asse che genera numeri casual i ,3 / / mi gl i or e del r andom di s i st ema4 / /5 publ i c c l ass RandomGener at or {6 / /7 / / get( ) : r est i t ui sce un numero compr eso t r a 0 e 189 publ i c doubl e get ( )

10 {

11 / /12 / / Cost ant i13 / /14 f i nal i nt a = 16087;15 f i nal i nt m = 2147483647;16 f i nal i nt q = 127773;17 f i nal i nt r = 2836;1819 / /20 / / Var i abi l i21 / /22 doubl e l o, hi , t est ;2324 hi = Mat h. cei l ( seed / q) ;25 l o = seed - q * hi ;

26 t est = a * l o - r * hi ;27 i f ( t est < 0. 0) {28 seed = t est + m;29 } el s e {30 seed = t est ;31 } / * endi f * /32 return seed / m;33 }3435 / /36 / / get Seed( ) : r est i t ui sce i l val or e cor r ent e del seme37 / /38 publ i c doubl e get Seed( )39 {40 return seed;

41 }4243 / /44 / / setSeed( s) : i mpost a i l val or e del seme a s45 / /46 publ i c voi d set Seed( doubl e s)47 {48 seed = s;49 }5051 / /52 / / cost r ut t ore del l a cl asse, genera un' i st anza di RandomGenerat or,53 / / f i ssando i l seme i ni z i al e a s .54 / /55 publ i c RandomGener at or ( doubl e s)

56 {57 seed = s;58 }5960 pr i vat e doubl e seed;6162 / /63 / / esempi o di uso del l a cl asse RandomGenerat or,64 / / st ampa 10 numer i casual i compr esi t r a 1 e 10065 / /66 publ i c s t at i c voi d mai n( St r i ng[ ] args)67 {68 l ong n, i ;69 / /70 / / cr ea un i st anza del l a cl asse RandomGenerat or

71 / /72 RandomGener at or r = new RandomGener at or ( 123456789) ;7374 Syst em. out . pr i nt l n( " I l val ore i ni z i al e del seme e' : " + r . get Seed( ) ) ;75

34


35/35

76 f or ( i = 1; i

laboratorio di asd - i progetto

Documents