1. Che cosa succede all'istogramma di questo link, se l'operatore di assegnazione (operator=()) viene chiamato su se stesso? In altre parole, se si programma:
istogramma mioIstogramma (/* parametri */) ;
mioIstogramma = mioIstogramma ;
che cosa succede a mioIstogramma?
2. implementare il copy constructor e l'operator=() per la classe vettore tenendo presenti le considerazioni del punto 1.
Ciao a tutti,
ho svolto l'esercizio sull'insieme di Mandelbrot.
Sul gruppo potrete trovare il file MandelbrotKri_02.cpp da scaricare .
Ditemi cosa ne pensate!! Ogni commento è gradito!
P.s.: ricordatevi di scaricare anche i file sui complessi (complessiKri.he complessiKri.cc ) altrimenti non funziona.
N.B.: il programma genera anche un file chiamato output.txt che contiene la lista dei valori assunti dalla funzione RunOut per ogni numero complesso analizzato.
A grande richiesta (da leggersi... me l'ha chiesto Enzo) potrete trovare il file MandelbrotKri_ASCII.txt che è la copia di un output ottenuto con il programma di cui sopra usando i numeri:
z1 = -3-3i
z2 = 3+3i
intervalli = 8100.
Modifica 28-dic: Ho aggiunto un altro file dell'output : MandelbrotKri_ASCII02.txt.
Ciao!
Stavo facendo qualche "vecchio" esercizio ed avevo una curiosità.
In particolare mi stavo occupando della classe istogramma (che non ho ancora fatto perchè mi ero occupato della classe complessi, ndt).
Dopo aver creato l'header file.h ho iniziato a scrivere il file .cc con l'implementazione della funzione riempi()
dichiarata nel seguente modo nel file .h:
void riempi(const double dato);
la funzione serve a inserire un dato nell'istogramma.
Mi è venuto in mente che servirebbe qualche controllo a proposito del dato inserito, per esempio:
"Cosa si fa se il dato inserito è minore del minimo valore rappresentato o maggiore del massimo?"
a questo punto l'idea è stata (prendiamo per esempio dato < min):
i) perdere il dato (scelta sconsigliata, credo)
ii) salvare il dato, ma non rappresentarlo (sono possibili diverse soluzioni)
iii) rappresentare il dato (modificando non poco l'istogramma), in particolare in questo caso potrei:
a] modificare il minimo in modo da rappresentare il nuovo dato e aggiungere tanti bin con lo stesso step di quelli dell'istogramma precedente (in pratica, se lavorassi con carta e matita allungherei il foglio e aggiungerei tante colonne (vuote) e poi una colonna in fondo a sx nella quale rappresento il nuovo dato)
b] modificare il minimo e calcolare un nuovo step (per esempio mantendo il numero di colonne uguale a quello precedente (di nuovo in pratica, cancello con una gomma le etichette degli intervalli delle colonne dell'istogramma e metto intervalli più larghi in modo da arrivare a contenere anche l'ultimo dato )
c] chiedo all'utente di scegliere di nuovo il numero di colonne che gli aggradano
Sia i punti i), ii), iii), come pure a], b], c] richiedono scelte da parte dell'utente che sarebbe bello poter fare run-time (leggi: l'utente inserisce il dato dall'esterno il programma vede che non va bene e allora si mette a chidere all'utente come si deve comportare).
La domanda che volevo fare è la seguente:
si può inserire scrivere tutta questa procedura di controllo come una funzione all'interno di una classe, senza che sia un metodo della classe. (come se fosse una funzione a parte, insomma, perchè è una specie di sottometodo)?
Da notare che per tutto il lavoro che ci sarebbe da fare sul vettore dei bins dell'istogramma sarebbe utile avere a disposizione un bell'array dinamico riallocabile (quindi prima dovrei mettermi a fare l'esercizio sulla classe dei vettori, oppure usare gli std::vector).
Dite che è troppo complicata tutta questa procedura?
Allora... se sì abbiamo tre possibilità I), II), III)... se no abbiamo... vabbhé lasciate perdere... sto delirando.
Fatemi sapere.
Ciao ciao
Cristian
Un esercizio semplice per prendere dimestichezza con i std::vector : provare a sostituire l'array dentro alla classe istogramma con std::vector.
Come sempre, pubblicate il risultato!
Finalmente ho capito come si riescono a fare i link per pubblicare i programmi
Per adesso, meglio tardi che mai, metto a vostra disposizione il programma sulla classe istogramma (vedi i files pubblicati da davide 1986). In particolare mi piacerebbe ricevere qualche commento sui metodi per visualizzare a schermo l'istogramma: ho tentato di ingegnarmi come meglio potevo, anche se sono sicuro che ci sono dei metodi più eleganti e precisi dei miei.
Allora, avete risolto i precedenti esercizi? Eccone un altro, semplice ma importante. Questo, ancor più degli altri, è importante che lo risolviate entro la prossima lezione! A proposito: ricordatevi il cambiamento d'orario!!!
Ho provato ad ottemperare al punto C) degli esercizi ed ho uploadato sul gruppo di discussione la mia modesta soluzione.
In particolare, non ho trovato il modo soddisfacente per:
Ciao a tutti,
volevo ricordarvi che oltre al Blog ed ai Quaderni esiste anche un gruppo di discussione di Google relativo al laboratorio, si chiama LabInfoDocet.
Trovate il link (permanente) a destra.
Il gruppo è utile perchè:
1. riporta tutti i messaggi del blog.
2. da la possibilità di caricare facilmente files (come se fossero allegati di una e-mail) che diventano disponibili per tutti (e così non dovete fare "copia-incolla" nel blog).
3. ci si può iscrivere al servizio di ricezione dei post via e-mail (così sarete sempre aggiornati).
... and much more.
Un assaggio, qui di seguito i link a due file (uno di Eugenio e l'altro mio) che riguardano le classi "complesso" e "istogramma":
Istogramma Eugenio.cc
complessiKri.h
(p.s. Eugenio non mi ha mai chiesto di sbattere il suo file in prima pagina sul blog... però spero che non si arrabbi per questo!!)
Turno del mattino:
ecco un'altra possibile implementazione di una funzione di ricerca di un minimo locale di una funzione.
Ecco fatto, ho finalmente modo di chiedere consigli:ho scritto un programmino che genera la distribuzione, traccia il solito istogramma attraverso una funzione alla quale passo dei vettori.Per questi utilizzo l'allocazione dinamica.Ma DevC++ mi segnala alcune cose che riguardano i vettori e la funzione. Peto auxilium socios.
Ho corretto un po' di stupidate che non andavano e lo ripropongo.Spero che sia possibile chiamare un vettore ed una singola variabile con lo stesso nome, ma mi hanno già ripreso a proposito(sono testardo).Ecco il codice(18.46).Grazie per la pazienza.
P.s. Ecco la versione testo del codice.
ciao,
per ricevere via email i post sottomessi al blog, ci si puo' registrare alla mailing list di google linkata qui:
http://groups.google.com/group/labinfodocet/about?hl=en
A questo proposito, è forse il caso di anticipare in questo post dei quaderni, una discussione più dettagliata sul modo ottimale con cui passare parametri a una funzione.
Allora allora...ho messo insieme le informazioni sulle classi inventandomi un piccolissimo programma, soltanto che ci sono delle cose che non mi sono ancora chiare e così lo posto, chiedendo a Enzo se mi potrebbe correggere i milioni di errori che ho commesso...
Mi vergogno un po' dopo i sofisticati programmi di Eugenio a postare i miei banali dubbi...però siccome vorrei imparare...!!!
Temo di aver fatto confusione coi vettori e le loro dichiarazioni...Aspetto correzioni (e sgridate!)
# include
# include
# include
//andrebbe fatto
//un programma di questo tipo e non so come fare se non postandolo...
//promettete di non ridere per la mia incapacità!!
class data //domanda1: posso usare dei vettori come componenti della classe?
{
int dd[2];
int mm[2];
int yy[4];
}
data Chegiorno(data oggi) //temo di aver sbagliato qualcosa qui...
{
data domani;
data domani= oggi.dd[]+1; //non so bene come rendere questo, so che è sbagliato..
return domani;
};
int main()
{
data oggi,domani; //istanza della classe data
oggi.dd[]= 05;
oggi.mm[]= 11;
oggi.yy[]= 2006;
domani= Chegiorno(oggi);
std::cout << "la data di oggi è: " << //cosa scrivo qui?? << std::endl;
std::cout << "la data di domani è: " << //e qui??? << std::endl;
return 0;
}Ecco dei brevi promemoria sugli argomenti trattati nell'ultima lezione. A parte gli operatori del C++ new e delete, dovrebbero essere tutti argomenti di non nuovi, ma pensiamo possano risultare comunque di una qualche utilità:
1. Array
2. Puntatori
3. Allocazione dinamica della memoria
4. Algebra dei puntatori
5. Procedure e funzioni
Buona sera a tutti. Vorrei proporre qualche idea per qanto riguarda la questione degli estremi del codominio della pdf.
1: Estremo inferiore. Per definizione, una pdf è una funzione da R in R, non negativa e normalizzata (come sottolineava Enzo). Dunque, è necessario che l'estremo inferiore del codominio sia zero: infatti, se l'inf fosse negativo questa sarebbe una contraddizione della non negatività della funzione, e se fosse positivo renderebbe impossibile la convergenza dell'integrale su tutto il dominio (cioè R) a un valore finito. Questo dovrebbe tranquillizzarci..
2: Estremo superiore. Ho provato, seguendo le indicazioni nei link, a scrivere una funzione che calcoli il massimo della pdf. La cosa che ho preparato (qua sotto trovate il codice) si ferma quando trova un massimo relativo, ed è quindi adatta a funzioni con un solo massimo (o che assumano lo stesso valore su ogni max relativo). Ho provato a implementarla nel codice di Pietro, e funziona, nonostante sia un po' rozza e non proprio un capolavoro di eleganza. Spero che i commenti siano sufficienti a renderla comprensibile.
//L'algoritmo restituisce il primo max relativo che trova calcolandolo con un errore relativo tol, guardando prima a destra dell'intervallo iniziale e poi a sinistra.
#include <iostream>
#include <cmath>
double goldmax(double func(double), double ax, double bx, double cx, double tol);
double expsearch(double func(double), double a, double b, double c, double tol, int k, double a0, double b0);
//Brentmax effettua una prima sezione aurea di [a,c] e passa i tre punti trovati a goldmax (se sono già 'buoni') oppure a expsearch.
//>>------------------------------
double brentmax(double func(double), double a, double c, double tol){
float b=c-((3.0-sqrt(5))/2)*(c-a);
if ((func(a) < func(b) && func(b) < func(c)) || (func(a) > func(b) && func(b) > func(c))){
return expsearch(func, a, b, c, tol, 0, a, b);
}else{
return goldmax(func, a, b, c, tol);
}
}
//>>-------------------------------
//Goldmax applica il metodo della sezione aurea per trovare il massimo a partire da un intervallo a<b<c tale che f(a)>f(b), f(c)>f(b). (questo codice è più o meno tradotto da quello che ho trovato all'indirizzo http://linneus20.ethz.ch:8080/1_5_2.html, da dove ho preso anche l'idea per il metodo esponenziale di brent)
double goldmax(double func(double), double ax, double bx, double cx, double tol){
double C=(3.0-sqrt(5))/2.0;
double R=1-C;
double x0=ax;
double x1;
double x2;
double x3=cx;
if (fabs(cx-bx) > fabs(bx-ax)){
x1=bx;
x2=bx+C*(cx-bx);
}else{
x2=bx;
x1=bx-C*(bx-ax);
}
double f1=func(x1);
double f2=func(x2);
int k=0;
while (fabs(x3-x0) > tol*(fabs(x1)+fabs(x2))){ //sul modo in cui questa condizione tiene d'occhio l'errore relativo ho qualche vaga idea, ma non sono troppo sicuro.. però funziona..
//std::cout << "k=" << k << "|a-b|=" << fabs(x3-x0) <<"<-->";
if (f2 > f1){
x0=x1;
x1=x2;
x2=R*x1+C*x3; // x2=x1+C*(x3-x1)
f1=f2;
f2=func(x2);
}else{
x3=x2;
x2=x1;
x1=R*x2+C*x0; // x1=x2+C*(x0-x2)
f2=f1;
f1=func(x1);
}
++k;
}
double xmax;
if(f1 > f2){
xmax=x1;
}else{
xmax=x2;
}
return xmax;
}
//Expsearch è una funzione ricorsiva. Prepara a goldmax un intervallo adatto, partendo da un intervallo qualunque. Se quello fornito da fuori non va bene, comincia dilatandolo verso destra (metodo della ricerca esponenziale di brent); se dopo 100 passaggi non ha trovato un massimo in questa direzione, torna all'intervallo di partenza e ripete la procedura verso sinistra. Se non trova niente nemmeno qui fornisce 1234567890 come valore 'di errore'. Non sono riuscito a farle dare Inf come output..
double expsearch(double func(double), double a, double b, double c, double tol, int k, double a0, double b0){
if ((func(a) <= func(b) && func(b) <= func(c)) || (func(a) >= func(b) && func(b) >= func(c))){
double R=2/(sqrt(5)-1);
++k;
if(k<100){
//std::cout << "Expsearch (destra): livello " << k << "<-->";
double x=c+R*(c-b);
return expsearch(func, b, c, x, tol, k, a0, b0);
}else if(k==100){
//std::cout << "Expsearch (sinistra, primo): livello " << k << "Valore" << "<-->";
double x=a0-R*(b0-a0);
return expsearch(func, x, a, b, tol, k, a0, b0);
}else if(k<200){
//std::cout << "Expsearch (sinistra): livello " << k << "Valore" << a << "<-->";
double x=a-R*(b-a);
return expsearch(func, x, a, b, tol, k, a0, b0);
}else{
return 1234567890;
}
}
return goldmax(func,a,b,c,tol);
}
Ho pensato che forse a qualcuno sarebbe stato utile rivedere un 'riassunto' dell'ultima esercitazione.. purtroppo non ho avuto molto tempo, così questo codice che vi posto è poco più di quello fatto in laboratorio (cioè: stampa un istogramma 'numerico' normalizzato rispetto all' 'altezza' della colonna più alta lavorando con una pfd arbitraria (nel codice ne ho incluse due, che ho dovuto definire perchè (nel caso di y=cosx+1) non erano funzioni di math.h o perchè (nel caso di y=x^2) non erano definite come funzioni di una sola variabile)). In particolare, non ho risolto il problema dell'estremo superiore del codominio della distribuzione (mentre, per quanto riguarda l'estremo inferiore, si usa sempre zero (anche se mi rendo conto che questo potrebbe generare qualche trascurabile incongruenza per pfd identicamente nulle in qualche punto, per via di come ho definito la condizione di ciclo in randFunc)).
Sperando di non aver fatto troppe stupidaggini, ho aggirato la questione del moltiplicare per 'quasi uno' facendo in modo che randFlat generi numeri nel chiuso e non nel semiaperto.
Se c'è qualcosa di sbagliato o incomprensibile fatevi sentire. Ci vediamo giovedì..
PS: cavoli. Non riesco a incollare direttamente qua sotto il codice. Che vergogna. Uso due immagini.
Ok, avete scritto una funzione per generare numeri casuali con una distrubuzione arbitraria (ad esempio con il metodo di reiezione). Ma come fate a capire se avete scritto davvero una cosa sensata? Provate a generare un campione di questi numeri casuali e provate a guardare come si distribuiscono! Ad esempio visualizzando un (rozzo) istogramma come quello che visualizza questo codice!
Questa può andare come soluzione dell'esercizio 3a? (e così avete capito anche qual è la sintassi per passare una funzione come argomento di una funzione...)
Ma se questa funzione-argomento è una probabilità, l'estremo inferiore (miny) non dovrebbe essere per forza zero? Funziona dunque lo stesso, l'algoritmo proposto? (c'è da aggiustare qualcosa, per quella questione di moltiplicare per quasi-uno il valore massimo della probabilità?)
Domanda da 100 punti: come faccio ad evitare di passare anche gli estremi del codominio della funzione di probabilità?
http://www.bloodshed.net/dev/devcpp.html
return 0;
char esci;
std::cin >> esci;
Riportiamo del materiale che, in qualche modo, riproduce quello visto nella prima lezione introduttiva: uno striminzito promemoria per l'input/output in C/C++, e una parziale riproduzione delle slide viste a lezione sulla funzione rand().
