Introduzione alla Libreria LEDA - Cosa è LEDA
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
•Vincenzo Auletta
Introduzione alla Libreria LEDA
Cosa è LEDA
ü LEDA è una libreria contenente implementazioni di
-02
algoritmi e strutture dati
Laboratorio di Algoritmi e Strutture Dati 2001
® Library of Efficient Data types and Algorithms
ü La libreria è strutturata in modo da poter essere
utilizzata anche da persone non esperte
® si possono utilizzare gli algoritmi e le strutture dati senza
conoscerne l'implementazione
ü LEDA è implementata in C++
® ogni struttura dati è implementata da un template di classe
® ogni algoritmo è implementato da un template di funzione
ü tutti i template possono essere istanziati con tipi definiti
dall'utente
1
•Corso di Programmazione in C++ •1•Vincenzo Auletta
Struttura della libreria
ü LEDA è strutturata su 5 archivi, ognuno dei quali contiene
l'immagine eseguibile di una parte delle funzioni della libreria
-02
ü esistono due versioni di ciascun archivio
Laboratorio di Algoritmi e Strutture Dati 2001
® archivio statico (.a) e archivio dinamico (.so)
ü LibL
® strutture dati base (liste, stack, vettori, stringhe, ecc.)
ü LibG
® strutture dati e algoritmi legati ai grafi (grafo diretto e non diretto,
array di nodi er archi, BFS, ecc.)
ü LibP
® strutture dati e algoritmi legati alla geometria del piano
ü LibW
® classi utilizzate per l'interfaccia grafica a finestre sotto X11
ü LibD3
® strutture dati e algoritmi legati alla geometria dello spazio LibD3
2
Come utilizzare la libreria
ü Per utilizzare una classe X di LEDA si deve
-02
Laboratorio di Algoritmi e Strutture Dati 2001
includere la dichiarazione (in genere X.h) e
linkare l'archivio contenente l'implementazione
di X
ü Gli header file della libreria si trovano nella
directory /usr/include/g++-include/LEDA
ü Gli archivi delle implementazioni si trovano in
/usr/local/lib
3
•Corso di Programmazione in C++ •2•Vincenzo Auletta
Esempio Utilizzo di Stack
// --------------------- prova.C -------------------------
#include
-02
Laboratorio di Algoritmi e Strutture Dati 2001
#include
int main() {
stack S;
S.push("ciao");
string s = S.pop();
return 0;
}
g++ prova.C –lL
4
Informazioni sulla libreria
ü E' possibile recuperare informazioni sulla libreria e sul
-02
Laboratorio di Algoritmi e Strutture Dati 2001
suo utilizzo da varie fonti
ü Manuale utente
® copia cartacea reperibile dal docente
® copia elettronica (formato ps o dvi) reperibile nella directory
/usr/share/doc/packages/leda
® copia html disponibile su Internet
ü Libro su Leda
® K. Melhorn, S. Naher, LEDA: A platform for Combinatorial
and Geometric Computing (disponibile in biblioteca)
ü sito della Algorithmic Solutions
® società proprietaria della libreria
5
•Corso di Programmazione in C++ •3•Vincenzo Auletta
Utilizzo del Manuale
ü Il manuale contiene una scheda per ogni struttura dati
-02
Laboratorio di Algoritmi e Strutture Dati 2001
presente nella libreria
ü Ogni scheda contiene
® definizione formale del tipo di dato astratto
® esempio di definizione di un oggetto
® lista dei prototipi dei metodi pubblici
w per ogni metodo viene descritta l'operazione corrispondente e sono
specificate eventuali precondizioni
® cenni sull'implementazione e sulla efficienza dei vari metodi
ü Per ogni algoritmo viene specificato il prototipo della
funzione che lo implementa e le eventuali precondizioni
6
Controllo Precondizioni
ü Un metodo di una classe implementa correttamente la
corrispondente operazione solo se le precondizioni sono
-02
soddisfatte
Laboratorio di Algoritmi e Strutture Dati 2001
ü LEDA non garantisce che il metodo verifichi se le
precondizioni sono soddisfatte
® in alcuni casi le controlla
® il programma deve preoccuparsi di invocare un metodo solo se le
sue precondizioni sono soddisfatte
ü Se una precondizione non è soddisfatta il metodo
potrebbe comportarsi in modo non corretto
® l'errore non è della libreria
ü Per motivi di efficienza si può eliminare dal codice di
LEDA qualsiasi controllo sulle precondizioni
® compilare con l'opzione –D LEDA_CHECKING_OFF 7
•Corso di Programmazione in C++ •4•Vincenzo Auletta
Esempio Controllo Precondizioni
template T stack::pop();
-02
// precondizione: lo stack non è vuoto
Laboratorio di Algoritmi e Strutture Dati 2001
int main() {
stack S;
string s = S.pop();
// segmentation fault in stack::pop()
…
}
// versione corretta
if(!S.empty()) string s = S.pop();
8
Istanziazione dei Template della
libreria
ü Molte classi della libreria sono template che possono
-02
essere istanziati rispetto a qualsiasi tipo di dato
Laboratorio di Algoritmi e Strutture Dati 2001
® anche tipi definiti dall'utente
ü LEDA assume che una classe utilizzata per istanziare
uno dei suoi template soddisfi le seguenti condizioni
® costruttore di default, costruttore per copia, operatore di
assegnamento e distruttore
® operatori di input (>>) e output (•Vincenzo Auletta
Esempio Istanziazione Template
class Studente {
friend ostream& operator(const istream&, Studente&);
public:
Studente();
Studente(const Studente&);
Studente& operator=(const Studente&);
~Studente();
…
};
stack S;
dictionary D; // ERRORE
10
Esempio Istanziazione Template
class X {
friend ostream& operator(const istream&, X
&);
public:
X(); dictionary< X, int> D;
X(const X &); h_array< X, int> H;
X & operator=(const X &);
~ X();
};
int compare(const X &, const X &);
int Hash(const X &);
bool operator ==(const X &, const X &);
11
•Corso di Programmazione in C++ •6•Vincenzo Auletta
Tipi Ordinati
ü Diversi tipi di dati richiedono che le classi usate per
-02
istanziare il template siano ordinati
Laboratorio di Algoritmi e Strutture Dati 2001
® es. dizionari, code a priorità, sequenze ordinate
ü Se il tipo parametrizzato T deve essere ordinato allora
deve esistere una funzione per confrontare oggetti di tipo
T
template
int compare(const T& a, const T& b);
// = 0 se a == b,
// < 0 se a < b,
// > 0 se a > b
12
Tipi con Differenti Relazioni
d'Ordine
ü In alcuni casi si deve utilizzare un tipo ordinato T con
riferimento ad una relazione d'ordine diversa da
-02
Laboratorio di Algoritmi e Strutture Dati 2001
quella definita dalla compare
® Es. dizionario di stringhe ordinate per lunghezza
ü utilizza la macro DEFINE_LINEAR_ORDER per
creare una nuova classe che usa la nuova relazione
d'ordine
int str_len(const string&, const string&);
DEFINE_LINEAR_ORDER(string, str_len, string_len)
dictionary D; // D ordina le chiavi per lunghezza
ü passa al costruttore di dictionary la funzione da usare
per ordinare le chiavi
dictionary D(str_len);
13
•Corso di Programmazione in C++ •7•Vincenzo Auletta
Tipi Hashed
ü Alcune classi di LEDA applicano funzioni hash ai tipi
-02
Laboratorio di Algoritmi e Strutture Dati 2001
parametrizzati rispetto ai quali è definita la classe
® se T è un tipo hashed allora devono esistere le funzioni
template int Hash(const T& a);
template bool operator==(const T&, const T&);
ü Per tutti i tipi predefiniti esiste una funzione hash di
default
ü funzione di conversione ad intero (non efficiente)
14
Item
ü Tutta la libreria LEDA è basata sul concetto di item
-02
indirizzo di un contenitore che può mantenere dei valori
Laboratorio di Algoritmi e Strutture Dati 2001
®
(astrazione di puntatore C)
® non tutti gli item sono implementati come puntatori
ü Esistono diversi tipi di item
® dic_item, list_item, stack_item, node, edge
® string, point, pair
ü Una variabile di tipo list_item contiene l'indirizzo di un
oggetto list_container (nodo di una lista)
® i membri del contenitori sono detti attributi dell'item
® un list_container contiene un campo chiave, un campo
informazione e altri campi necessari ad implementare la
struttura dati sottostante
15
•Corso di Programmazione in C++ •8•Vincenzo Auletta
Tipi di Item
ü Tutti gli item della libreria possono essere divisi in due
-02
Laboratorio di Algoritmi e Strutture Dati 2001
categorie: item dipendenti ed indipendenti
ü item dipendenti
® indirizzano contenitori che esistono solo come elementi di una
collezione (nodi di una struttura dati)
® le due uniche operazioni consentite sono assegnamento e
uguaglianza
® Es. dic_item, list_item, stack_item, node, edge
ü item indipendenti
® indirizzano contenitori che sono auto sufficienti
® string, point, line, pair
® non possono modificare gli attributi del contenitore
16
Uguaglianza tra Item
ü Il significato dell'operatore di uguaglianza è
-02
Laboratorio di Algoritmi e Strutture Dati 2001
diverso per i vari tipi di item
ü due item dipendenti sono uguali se indirizzano lo
stesso contenitore
® bool operator==(const list_item&, const list_item&);
ü due item indipendenti sono uguali se puntano a
contenitori che contengono gli stessi valori
® bool operator==(const string&, const string&);
ü due item indipendenti che indirizzano lo stesso
contenitore sono identici
® bool identical(const string&, const string&);
17
•Corso di Programmazione in C++ •9•Vincenzo Auletta
Strutture dati come Collezioni di
Item
ü Molte strutture dati di LEDA sono costituite da collezioni
-02
Laboratorio di Algoritmi e Strutture Dati 2001
di item dipendenti
® la collezione ha una organizzazione definita dalla struttura dati
ü list
® collezione di list_item, ognuno dei quali indirizza un nodo con un
campo informazione di tipo K e punta al nodo successivo
ü dictionary
® collezione di dic_item, ognuno dei quali indirizza un nodo
contenente un campo chiave di tipo K e un campo informazione
di tipo I
® i campi chiave dei nodi devono essere distinti e K deve essere un
tipo su cui è definta una relazione d'ordine
18
Operazioni su Strutture Dati
ü Le strutture dati definite come collezioni di item
-02
implementano le loro operazioni con metodi che lavorano
Laboratorio di Algoritmi e Strutture Dati 2001
sugli item
® è illegale usare l'item dopo che la struttura dati è stata distrutta
template
class dictionary { dictionary rubrica;
public: /* incrementa il valore
dic_item lookup(K key); associato alla chiave mario */
I inf(dic_item it); dic_item it = rubrica.lookup("mario");
void change_inf(dic_item it, I int n = rubrica.inf(it);
new_val); rubrica.change_inf(it, n+1);
…
};
19
•Corso di Programmazione in C++ •10•Vincenzo Auletta
Copie ed Assegnamenti
ü Tutte le classi di LEDA hanno costruttore per
-02
Laboratorio di Algoritmi e Strutture Dati 2001
copia, operatore di assegnamento e distruttore
definiti opportunamente
ü Copiare un oggetto di una classe significa
copiare tutti i suoi item
® gli item dipendenti vengono duplicati
® gli item indipendenti vengono gestiti con il reference
counting
20
Passaggio dei Parametri
ü La libreria utilizza il passaggio per valore solo
-02
Laboratorio di Algoritmi e Strutture Dati 2001
per passare argomenti di tipo predefinito
ü Argomenti di tipo parametrico e di tipo non
predefinito sono sempre passati per riferimento
® se l'argomento non deve essere modificato il
riferimento è costante
21
•Corso di Programmazione in C++ •11•Vincenzo Auletta
Iterazioni
ü I tipi di dato formati da collezioni di item
-02
Laboratorio di Algoritmi e Strutture Dati 2001
possono essere scanditi attraverso delle iterazioni
® implementate come macro
® nascondono all'utente la struttura delle classi della
libreria
ü Un'iterazione su una collezione di item C deve
soddisfare le seguenti condizioni
® non può aggiungere item alla collezione
® può modificare gli attributi di un item
® può rimuovere un item solo quando lo sta visitando
22
Tipi di Iterazioni
forall_items(it, D)
forall_rev_items(it, D)
-02
Laboratorio di Algoritmi e Strutture Dati 2001
// tutti gli item di D sono assegnati in successione a it
// solo per le liste e gli insiemi
forall(s, L)
forall_rev(s, L)
// solo per i grafi
forall_nodes(v, G) // scorre tutti i nodi di G
forall_edges(e, G) // scorre tutti gli archi di G
forall_adj_edges(e, v)
// scorre la lista degli archi adiacenti al vertice v
23
•Corso di Programmazione in C++ •12•Vincenzo Auletta
Esempi di Iterazioni
list L;
list_item s;
-02
Laboratorio di Algoritmi e Strutture Dati 2001
…
forall(s, L)
if(L[s] == 5) L.del(s);
// cancella dalla lista L tutti i nodi che contengono 5
graph G;
…
node v, s = G.new_node();
forall_nodes(v, G)
if(s != v) G.new_edge(s, v);
// aggiunge un nodo s a G e lo collega a tutti gli altri nodi
24
Iterazioni stile STL
ü Alcuni tipi di dati di LEDA consentono anche di
-02
Laboratorio di Algoritmi e Strutture Dati 2001
scorrere la collezione di item utilizzando gli
iteratori della libreria standard (STL)
list L;
int cont = 0;
…
for(list::iterator it = L.begin(); it != L.end(); it++)
if(*it == 5) cont++;
// conta il numero di occorrenze di 5 in L
25
•Corso di Programmazione in C++ •13•Vincenzo Auletta
Utilizzo di LEDA con STL
ü Per evitare conflitti di nomi tr classi di LEDA e
-02
Laboratorio di Algoritmi e Strutture Dati 2001
di STL in compilatori che non supportano i
namespace a tutte le classi di LEDA è aggiunto
automaticamente il prefisso leda
® Es. list à leda_list
ü Se si vuole eliminare l'inserimento del prefisso
davanti al nome di tutte le classi della libreria si
deve compilare il programma con l'opzione
–D LEDA_PREFIX
26
Parametri di Implementazione
ü Per i dizionari, le code a priorità e le sequenze
-02
Laboratorio di Algoritmi e Strutture Dati 2001
ordinate è possibile scegliere la struttura dati
che deve essere utilizzata per l'implementazione
// implementazione di default
#include
dictionary D;
// implementazione con alberi RossoNeri
#include
#include
_dictionary
ü E' possibile fornire la propria implementazione
27
•Corso di Programmazione in C++ •14•Vincenzo Auletta
Esempio: Contatore Parole
ü Calcola il numero di occorrenze di ogni parola in un testo
-02
Laboratorio di Algoritmi e Strutture Dati 2001
#include
#include
void main() {
d_array cont(0);
string s;
while(cin >> s) cont[s]++;
forall_defined(s, cont)
cout•Vincenzo Auletta
Esempio: BFS -- 2
while(!Q.empty()) {
color[s]=GRAY;
-02
u=Q.pop();
Laboratorio di Algoritmi e Strutture Dati 2001
d[s]=0;
forall_adj_nodes(v,u){
Q.append(s);
if (color[v]==WHITE) {
color[v]=GRAY;
d[v]=d[u]+1;
pred[v]=u;
Q.append(v);
}
color[u]=BLACK;
}
}
30
Esempio: Costruzione di un Grafo
Casuale
#include
#include
-02
Laboratorio di Algoritmi e Strutture Dati 2001
#include
cout > e;
graph G;
random_simple_undirected_graph(G,n,e);
Make_Bidirected(G);
StampaGrafo(G);
31
•Corso di Programmazione in C++ •16•Vincenzo Auletta
Esempio: Chiamata di BFS
-02
Laboratorio di Algoritmi e Strutture Dati 2001
node_array distanza(G,9999);
node_array colore(G,WHITE);
node_array pred(G,NULL);
node s = G.choose_node();
bfs(G, s, distanza, colore, pred);
32
•Corso di Programmazione in C++ •17Puoi anche leggere
