UNIVERSITA’ DEGLI STUDI ROMA TRE
DIPARTIMENTO DI FISICA “E. AMALDI”
laboratorio di calcolo II
AA 2003/04
a cura di
Domizia Orestano
Dipartimento di Fisica
Stanza 159 - tel. (06 5517) 7281
www.fis.uniroma3.it/~orestano
[email protected]
1
Introduzione: obiettivi del corso
Introduzione alla Programmazione ad Oggetti
Accento posto sulle “Idee” e non sugli aspetti tecnici
“Architetti”
e non
“Esperti del Linguaggio C/C++”
Imparare a progettare un approccio al Calcolo
Restano fuori
Elementi di Analisi Numerica
Aspetti di Grafica o di Tecnologie Multimediali
2
Introduzione: organizzazione del corso
Contenuti
Metodo
1.
1.
2.
3.
Introduzione al
linguaggio C++ e
alla Programmazione
ad Oggetti
Elementi di
linguaggio UML
Elementi di strutture
riutilizzabili
2.
3.
4.
Comprensione del problema,
ricerca della soluzione in ambito
OO, implementazione in C++
Lezioni Frontali (circa 40%) e
Laboratorio (circa 60%)
Utilizzo di un problema guida
(Sistema Solare)
Sintassi in Appendice a
ciascuna lezione
3
Introduzione: orario del corso
Indicativamente... Abbiamo 10 settimane
• 10 o 11 lezioni frontali da 2 ore
–
–
–
–
0.5 - Introduzione
8.5 - Linguaggio C++
1.5 - UML e strutture riutilizzabili
0.5 - Conclusione
Si svolgeranno il lunedì dalle 14 alle 16
• 9 o 10 esercitazioni di laboratorio da 4 ore
Si svolgeranno presso i laboratorio didattici il martedì
(studenti del II anno) e il giovedì (studenti del I anno)
dalle 9 alle 13
4
Introduzione: strumenti di lavoro
•
•
•
Dispense
Esercitazioni di Laboratorio (in gruppi di 2 persone)
Manuale C++
–
–
–
Come riferimento per la sintassi
Attenzione all’impostazione (partiamo direttamente dal
C++, e non dal C!)
Alcuni suggerimenti nella prossima trasparenza
•
Presenza attiva in Laboratorio e in Aula
5
Introduzione: manuali (1)
6
Introduzione: manuali (2)
7
Introduzione: svolgimento degli esami
•
Prova Pratica
–
•
•
Prova in Laboratorio, in linguaggio C++
Prova Orale
Discussione su un problema scelto dallo studente e
preparato personalmente durante il corso
–
–
–
Ogni studente sceglie un problema di Fisica (semplice!)
concordato o suggerito dal docente
Lo formalizza nella logica della programmazione ad
oggetti
Lo scrive in C++ e lo discute nel corso della Prova Orale
8
Problematiche del calcolo moderno
Applicazione del calcolo a sistemi sempre più complessi per quantità di dati da
manipolare, numero di CPU utilizzate, distribuzione geografica dei soggetti
coinvolti
Esempi: esperimenti di fisica delle alte energie
e di astroparticelle,
biologia molecolare
e progetto genoma,
ma anche telecomunicazioni,
sistemi bancari, reti di trasporto.
9
Requisiti per il software moderno
1.
Robustezza
protezioni nell’accesso ai dati
2.
3.
4.
Possibilità di ri-utilizzo del codice
1.
economia di risorse umane ed economiche
2.
maggiore affidabilità
Portabilità
1.
verso sistemi operativi diversi
2.
verso diverse versioni di uno stesso sistema
Flessibilità e Organizzazione del Codice
semplicità di gestione e sviluppo successivo del codice
10
Paradigmi di programmazione
Procedurale: si sceglie l’algoritmo che risolva il problema dato e il linguaggio
permette di implementare l'algoritmo scelto
Modulare: si decide quali moduli utilizzare e si separano i dati in modo da nasconderli
entro ciascun modulo
Definita dall’utente: si decide quali tipi utilizzare e si genera un insieme di
operazioni per i vari tipi
Orientata agli Oggetti: si decide quali classi utilizzare, si genera un insieme di
operazioni per le varie classi e si raggruppano le proprietà comuni tramite il
meccanismo dell'ereditarietà
Generica: si identificano una serie di algoritmi e si parametrizzano in modo che
possano essere utilizzati per più classi o tipi definiti dall'utente.
11
Paradigmi e linguaggi di
programmazione
I diversi linguaggi di programmazione possono essere più o meno
indicati ad esprimere un tipo di programmazione (paradigma).
Il C++ permette di implementare una programmazione definita
dall'utente, consentendo la definizione di tipi di oggetti e delle
operazioni effettuabili con essi, con possibilità di mettere in evidenza i
collegamenti e le similitudini tra di essi mediante il meccanismo
dell’ereditarietà (ovvero una programmazione Orientata agli Oggetti) ma
consente anche di realizzare una programmazione Generica, creando
codice utilizzabile in situazioni formalmente simili anche in assenza di
un collegamento concettuale.
12
Caratteristiche della programmazione OO
1.
Incapsulamento: i dati dell’oggetto sono nascosti ad altri oggetti ed è
possibile accedervi solo attraverso modalita’ ben definite
Da questa caratteristica derivano robustezza e flessibilità del codice
2.
Ereditarietà: gli oggetti complessi possono essere costruiti a partire da oggetti
più semplici. Gli oggetti complessi derivano tutto o parte del loro
comportamento dagli oggetti a partire dai quali sono stati generati
Ne derivano ri-utilizzabilità e possibilità di organizzazione del codice
3.
Polimorfismo: oggetti simili possono essere trattati, in alcuni casi, come se
fossero dello stesso tipo, senza la necessità di implementare trattamenti specifici
per distinguere tra le varie tipologie
Rende il codice più flessibile e aumenta l’efficienza dell’ereditarietà
La Portabilità invece è una caratteristica del linguaggio ed in particolare del
C++ standard (ANSi-C++)
13
Progettazione di un programma
•
Scelta degli Oggetti
•
Identificazione delle relazioni tra gli Oggetti (proprietà statiche o
“geometriche”)
•
Esame dei casi d’uso (use case)
•
Identificazione delle interazioni tra gli Oggetti (proprietà dinamiche)
•
Eventuale ridefinizione delle responsabilita’ delle classi
NB gli Oggetti vengono descritti mediante classi, ovvero tipi definiti
dall’utente che realizzano l’incapsulamento dei dati
14
La simulazione del Sistema Solare
Il problema fisico:
Determinare l’evoluzione temporale di un certo numero di corpi
sottoposti a reciproca attrazione gravitazionale
F12= m a
F12= - G m1 m2 r / r3
G = 6.673e-11 Unità mks
15
Scelta degli Oggetti
Quali “Oggetti” entrano nel problema?
corpi celesti, sonde, pianeti, stelle, satelliti …
Quali proprieta’ hanno tali oggetti?
massa, posizione, velocità…
16
Relazioni tra gli Oggetti
Quali sono le relazioni tra gli Oggetti? Possono essere raggruppati?
Quali proprieta’ sono condivise da Oggetti simili?
Quali proprieta’ permettono di distinguere Oggetti simili tra loro?
un pianeta è un corpo celeste, una sonda è un satellite…
… ed è anche un corpo celeste
tutti gli oggetti possono essere ricondotti a Corpi Celesti o a Sonde,
dove la Sonda è un Corpo Celeste con qualche proprietà in più
Quali oggetti sono superflui? Quali oggetti mancano?
manca il Sistema Solare
… e un Sistema Solare è composto da dei Corpi Celesti!
17
U
M
L
Universal
Modeling
Language
18
Casi d’uso
A cosa serve esattamente il programma?
simulazione del moto dei vari Corpi Celesti inseriti nel Sistema Solare
In quali situazioni concrete tali oggetti dovranno essere utilizzati?
1.
Si vuole conoscere lo stato del sistema (posizione di ciascun Corpo Celeste)
dopo un tempo T dall’istante iniziale
2.
Si suddivide l’intervallo T in n intervallini dT nei quali si possano trascurare
variazioni di forza e di velocità
3.
Per ogni intervallo dT
1.
Nota la posizione di ciascun Corpo Celeste all’inizio dell’intervallo
2.
La si usa per determinare la forza agente su ciascun Corpo Celeste
3.
Nota la forza si determina l’accelerazione di ogni Corpo Celeste
4.
Si calcola la velocità del Corpo Celeste, nota la velocità all’inizio dell’intervallo,
assumendo che l’accelerazione resti costante
5.
Si calcola la nuova posizione, assumendo che la velocità resti costante
19
Scenari
Oltre ai casi d’uso si possono introdurre gli scenari. Questi descrivono in
maniera piu’ dettagliata situazioni particolari che possono presentarsi e
devono essere previste dal programma.
Nel nostro caso possiamo ad esempio prevedere di voler lanciare una sonda
dalla superficie di un altro Corpo Celeste X ad un istante t compreso tra 0 e
T. Il programma dovrà allora anche controllare quando si raggiunga il
tempo t e aggiungere al Sistema Solare un Oggetto Sonda con una certa
velocità iniziale rispetto al Corpo Celeste X, assegnandole la posizione di X
ed una velocità ottenuta dalla combinazione della velocità iniziale relativa
della Sonda rispetto a X e della velocità del Corpo Celeste X.
20
Interazioni tra gli Oggetti
Non è sufficiente capire la relazione “geometrica” tra gli oggetti, è necessario
anche valutare come gli oggetti interagiscono “dinamicamente” tra loro
Quali compiti ha ciascuna classe?
Chi determina le nuove coordinate del sistema?
Chi invoca i metodi per far evolvere il sistema?
Una possibile scelta:
•
CorpoCeleste ha il metodo CalcolaPosizione
•
SistemaSolare ha il metodo Evolvi che determina il nuovo stato
del sistema dopo un tempo T
•
Il metodo Evolvi (di SistemaSolare) si occupa di invocare i metodi
CalcolaPosizione di ciascun pianeta del sistema solare.
21
Responsabilità delle classi
è chiaro di chi sia la responsabilita’ di un punto chiave del programma?
Una classe ha troppe responsabilita’?
Una classe è irrilevante e può essere “assorbita” da un’altra?
• Distribuire le responsabilità tra le varie classi
• Sfruttare un procedimento a cascata
• Limitare le responsabilità di una classe ad una o due
22
Interaction Diagram (semplificato)
23
Sessione CRC
CRC: Classi, Responsabilità, Collaborazione
capire come funziona dinamicamente il programma che si vuole realizzare
Giuoco di Ruolo:
• ciascuno dei partecipanti è un Oggetto del programma
• uno dei partecipanti è il Programma "Main
Ogni partecipante deve conoscere le caratteristiche di ciascuna Classe:
• "come è fatta"
• "quali azionì può compiere”
Durante la sessione tutto si svolge come nel corso dell'esecuzione del Programma,
in questo modo emergono casi non previsti ed eventuali problemi.
24
Costruzione di una classe
1. Attributi
•
public
•
private
•
protected
Set
Nome Classe
Get
Attributi
2. Metodi
•
public
•
private
•
protected
•
Obbligatorio il tipo
(“nessun tipo”
Metodi
void )
3. Accesso agli attributi di una classe
(tipo Set e tipo Get)
25
La dichiarazione di una classe: l’header file (.h)
Nomeclasse.h
Contiene la dichiarazione
degli Attributi e dei Metodi
CorpoCeleste
Nome (stringa)
m (num. reale)
x (num. reale)
y (num. reale)
vx (num. reale)
vy (num. reale)
CalcolaPosizione(forza, dt)
StampaVelocita’()
StampaPosizione()
M()
X()
Y()
Vx()
Vy()
26
L’implementazione di una Classe:
l’implementation file ( .cc)
Nomeclasse.cc
Contiene l’implementazione
degli Attributi e dei Metodi
27
#ifndef CORPOCELESTE_H
#define CORPOCELESTE_H
class CorpoCeleste {
private:
char *Nome;
double m;
double x;
double y;
double vx;
double vy;
CorpoCeleste.h
public:
CorpoCeleste() ;
CorpoCeleste
(const char *nomeCorpo, float mass,
float xpos, float ypos, float vxi,
float vyi);
~CorpoCeleste() ;
void calcolaPosizione
(float fx, float fy, float t);
void stampaPosizione();
void stampaVelocita() ;
const char *nome()
;
double M() ;
double X() ;
double Y() ;
double Vx() ;
double Vy() ;
};
#endif
28
#ifndef CORPOCELESTE_H
#define CORPOCELESTE_H
class CorpoCeleste {
protected:
char *Nome;
double m;
double x;
double y;
double vx;
double vy;
CorpoCeleste.h
con modifiche
per ereditarietà
public:
CorpoCeleste() ;
CorpoCeleste
(const char *nomeCorpo, float mass,
float xpos, float ypos, float vxi,
float vyi);
~CorpoCeleste() ;
virtual void calcolaPosizione
(float fx, float fy, float t);
void stampaPosizione();
void stampaVelocita() ;
const char *nome()
;
double M() ;
double X() ;
double Y() ;
double Vx() ;
double Vy() ;
};
#endif
29
#include "CorpoCeleste.h“
CorpoCeleste.cc
CorpoCeleste::CorpoCeleste( ) {
}
Schema vuoto
CorpoCeleste::CorpoCeleste
(const char *nomeCorpo, float mass,
float xpos, float ypos, float vxi, float vyi)
}
CorpoCeleste::~CorpoCeleste()
{
{
}
void CorpoCeleste::calcolaPosizione
(float fx, float fy, float t) {
}
void CorpoCeleste::stampaPosizione() {
}
void CorpoCeleste::stampaVelocita() {
}
const char* CorpoCeleste::nome()
double CorpoCeleste::M()
double CorpoCeleste::X()
double CorpoCeleste::Y()
double CorpoCeleste::Vx()
double CorpoCeleste::Vy()
{
{
{
{
{
{
}
}
}
}
}
}
30
#include
#include
#include
#include
CorpoCeleste.cc
"CorpoCeleste.h"
<string.h>
<iostream.h>
<iomanip.h>
CorpoCeleste::CorpoCeleste() {
Prima parte
}
CorpoCeleste::CorpoCeleste
(const char *nomeCorpo, float mass,
float xpos, float ypos, float vxi, float vyi) {
Nome = new char[strlen(nomeCorpo)];
strcpy(Nome, nomeCorpo);
m = mass;
x = xpos;
y = ypos;
vx = vxi;
vy = vyi;
}
void CorpoCeleste::calcolaPosizione(
float fx, float fy, float t) {
double ax = fx/m;
double ay = fy/m;
vx += ax*t;
vy += ay*t;
x += vx*t;
y += vy*t;
}
31
void CorpoCeleste::stampaPosizione() {
cout.setf(ios::fixed);
cout.setf(ios::showpos);
cout << " " << setprecision(4) << setw(9)
<< x*1.e-11 << " " << setprecision(4)
<< setw(9) << y*1e-11 ;
}
CorpoCeleste.cc
void CorpoCeleste::stampaVelocita() {
cout.setf(ios::fixed);
cout.setf(ios::showpos);
cout << " " << vx << " " << vy ;
}
CorpoCeleste::~CorpoCeleste()
{
Seconda parte
}
const char* CorpoCeleste::nome() {return Nome; }
double CorpoCeleste::M()
{ return m; }
double CorpoCeleste::X()
{ return x; }
double CorpoCeleste::Y()
{return y;
double CorpoCeleste::Vx()
{return vx; }
double CorpoCeleste::Vy()
{return vy; }
}
32
#ifndef CORPOCELESTE_H
#define CORPOCELESTE_H
class CorpoCeleste {
protected:
char *Nome;
double m;
double x;
double y;
double vx;
double vy;
CorpoCeleste.h
con impletazione
di alcuni metodi
“inline”
public:
CorpoCeleste() ;
CorpoCeleste
(const char *nomeCorpo, float mass,
float xpos, float ypos, float vxi,
float vyi);
~CorpoCeleste() { } ;
virtual void calcolaPosizione
(float fx, float fy, float t);
void stampaPosizione();
void stampaVelocita();
const char *nome() {return Nome;};
double M() {return m;};
double X() {return x;};
double Y() {return y;};
double Vx() {return vx;};
double Vy() {return vy;};
};
#endif
33