ancora esercizi

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!!!

esercizi

Ecco qualche esercizio per venerdì prossimo.
Ricordatevi il cambiamento d'orario!!!

***ATTENZIONE*** lezione del 1.12.06

Per venerdì prossimo è confermata la "compressione" dei due turni di laboratorio (solo per i gruppi 1 e 3, ne abbiamo già parlato a lezione), ma cambia l'orario: i due turni saranno al mattino, nei seguenti orari:

• 10.30-12.00: gruppo 3

• 12.00-13.30: gruppo 1
  

Nel primo turno ci sarà il gruppo (3) che aveva in programma il turno della mattina, quindi nel secondo turno ci sarà il gruppo (1) che aveva in programma il turno del pomeriggio.
Siete gentilmente ma caldamente invitati a spargere la voce anche ai compagni di corso che leggono la posta e/o il blog con meno regolarità!

Ci scusiamo ancora per il cambiamento improvviso di orario.

istogramma.cc

Ecco qui una possibile implementazione di istogramma.cc

Insieme di Mandelbrot

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:

1. rappresentare le etichette dei valori dell'asse x del piano di Argand-Gauss senza che tutto risulti un po' sballato.
2. rappresentare il suddetto piano come Dio comanda (e cioè con l'asse immaginario crescente verso l'alto) - Mi rendo conto che l'insieme di Mandelbrot è simmetrico rispetto all'asse reale e quindi la cosa non è fondamentale, ma è estremamente seccante - appunto per via delle etichette. Avevo pensato ad un algoritmo correttivo ma funziona bene solo per intervalli simmetrici rispetto a Im=0; se qualcuno ha voglia di perderci sopra del tempo, mi piacerebbe una bella soluzione universale (e che cioè vada bene per rappresentare a terminale tutti i grafici di R2, sapendo che per forza il computer deve scrivere dall'alto).
   

PS: Mentre scrivevo ho trovato una possibile soluzione che passo a testare: se, invece di fare il ciclo con (i=0;i < n_int ;i++)
, si fa con (i=n_int ; i > 0 ; i--), funziona?

Funziona. Bene.

Ricordatevi del gruppo

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!!)

compiti

Tassativo: per settimana prossima dovete arrivare in laboratorio con questi esercizi svolti completamente! Molti di voi hanno già svolto il punto A (meglio: l'abbiamo svolto quasi completamente insieme in classe...), e alcuni persino il punto B: non avete scuse!

domani lezioni regolarmente

Turno del mattino:

• 10:30-13:30 (direttamente in laboratorio)

Turno del pomeriggio:

• 14:30-17:30

singleton

a seguito di una domanda in laboratorio, trovate fra i quaderni un link ad una pagina web sui singleton.

spunti

Ricordo che avevamo già messo nei quaderni del blog, qui, parte delle slide che stiamo vedendo in queste ultime lezioni. Ora ne abbiamo aggiunte altre quattro (allo stesso indirizzo), per cui chi le avesse già viste ne troverà di nuove...
Usando i goolge-groups siamo anche riusciti a rendere disponibile per il download queste slide sulla programmazione ad oggetti (direttamente in formato pps, invece che gif...): per scaricarla, cliccate (o clickate) col tasto destro del mouse qui e selezionate l'opzione "save link as...", oppure "salva oggetto con nome...", o, insomma, l'opzione per salvare su disco e non per seguire il link (ovvero aprirlo nel browser...)
Per avere qualche spunto sulla programmazione ad oggetti, è disponibile anche una (rozza) versione di una classe per i numeri complessi: potete farne il download qui. Per la fretta, ho fatto tutto in un solo file .cc: sapreste "spezzarlo" in un header file .h e in un .cc che non contiene la definizione della classe (ma solo dei suoi metodi...)?
La risposta alla domanda precedente deve ovviamente essere sì. Ma provatevi, invece, a divertirvi usando quella classe per visualizzare l'insieme di Mandelbrot! Magari semplicemente in formato ASCII, come abbiamo fatto con gli istogrammi...

minimizzare funzioni

ecco un'altra possibile implementazione di una funzione di ricerca di un minimo locale di una funzione.

uso dei gruppi di google

A grande richiesta, ecco alcune indicazioni per utilizzare i gruppi (di discussione) di google.

Prologo: come di blogger, anche dei gruppi esiste una versione "vecchia" e una "beta": la versione beta offre maggori funzionalità, per cui d'ora in poi (il link che avevamo fornito prima era, ahinoi, alla versione vecchia...) privilegeremo quella. Inoltre metteremo d'ora in avanti i link già settati in italiano, così rendiamo le cose più facili...
Vi conviene loggarvi col vostro account di google (che avete creato quando vi siete iscritti al blog), prima di seguire i link che seguono, così che google riconoscerà chi siete e potrete iscrivervi al gruppo e settare tutte le personalizzazioni del caso (nonchè usufruire dei servizi che mette a disposizione...)

Il gruppo che abbiamo creato per il corso è a questo indirizzo:
http://groups-beta.google.com/group/labinfodocet?hl=it
che vi presenta una homepage generale dei servizi web-2.0 che offre. Questi sono essenzialmente 3 e trovate i link a ciascuno di essi nel menu che vi ritroverete sulla destra:

Discussioni
Questa è il nucleo del servizio originario dei gruppi di discussione: la mailing list. Abbiamo tirato in ballo i gruppi solo perchè questo poteva essere un modo semplice di avvisare via mail quando qualcuno avesse pubblicato sul blog un post o un commento. Per questo essenzialmente in questa sezione vedrete delle mail che riportano i commenti e i post che chiunque di voi/noi pubblicherà sul blog. E' possibile utilizzare questa sezione per mandare delle mail a tutti gli iscritti (senza che la mail venga pubblicata sul blog), ma sappiamo bene (ancora) se sconsigliare o meno tale pratica...
File
Questa è il servizio che per primo ci è apparso interessante, dopo quello di notifica-via-email: è possibile in questa sezione uploadare (riversare sul web, nei server di google) dei propri file, in modo che possano essere visibili da chiunque sia connesso alla rete. Rocco è già riuscito a farlo!
Pagine
Si tratta di una specie di modalità di pubblicazione à la blog: si scrivono delle pagine in un editor wysiwyg, eventualmente modificabile nel loro codice HTML. Attualmente a me non funzionano (!), ma ad esempio Rocco sembra sia riuscito a pubblicare una pagina...!

Buon divertimento!

Uso di "vettori dinamici"

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.

post via email

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

variabili globali (nient'affatto una questione di stile!)

Attenzione attenzione!!!
Nel mio post sulle procedure/funzioni ho fatto ricorso a variabili globali (i e j) usandole all'interno delle funzioni. Il motivo era quello di spiegare il modo con cui vengono gestite le variabili (globali, locali, passate per riferimento e passate per valore) all'interno delle funzioni, e in particolare quali sono le azioni che si ripercuotono all'interno del programma principale e quali invece hanno effetto solo all'interno (e per la sola durata) della funzione.
Di fatto, però, l'uso di variabili globali all'interno delle funzioni è fortemente sconsigliato. Di più, per quanto riguarda il corso, tale pratica è da considerarsi BANDITA, esattamente come l'uso di costrutti non-strutturati come il goto.
Il motivo è che la funzione, per sua stessa natura, deve essere il più possibile indipendente dal contesto o, meglio, deve potersi adattare a qualsiasi contesto. Per questo, tutto ciò di cui una funzione ha bisogno deve essere creato all'interno della funzione stessa (se il prosieguo del programma principale non ne ha più bisogno) oppure passato come parametro (se deve esserci una qualche comunicazione fra programma principale e funzione, sia essa in un senso, nell'altro o in entrambi).

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.

problemi di registrazione con blogger

Molti di voi lamentano problemi a registrarsi al blog. Non credo siano problemi di browser, mentre magari qualcuno di questi consigli di blogger potrebbe fare al caso vostro (ho re-inviato una mail di invito agli indirizzi che ancora non si sono registrati).
Un'altra possibile fonte di problemi è che abbiate già un account blogger, ma "vecchio tipo" (mentre il blog è già nella versione nuova, "beta", di blogger). In questo caso (il suggerimento credo abbia funzionato col lupo rock) non tentate di usare il vostro vecchio account, ma createne uno nuovo (eventualmente con lo stesso userID e pwd) e usate poi quello per registrarvi al blog di lab-info.
Provate a seguire questi consigli, e se ancora non ci riuscite... boh! (ma teneteci informati, che se nessuno di voi più si lamenta, diamo per risolto il problema!)
PS
I problemi a registrarsi dal laboratorio, invece, temo siano dovuto a un qualche filtro in dipartimento, perchè è proprio questione di irraggiungibilità di certi indirizzi (ad esempio gmail stessa...). Tradotto: provate a registrarvi da casa!

Ehm...

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 


//Mi scuso in anticipo per gli strafalcioni, il fatto è che vorrei vedere come
//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;  
}

Grazie e buona domenica a tutti!!!
Fra

Riferimenti e valori, puntatori ed array, etc etc...

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

Ancora sugli estremi del codominio di una pdf

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.

brentmax.cc

//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);
}

Indentare il codice

La lezione scorsa, fra le altre cose, abbiamo avuto modo di verificare l'utilità, per la programmazione strutturata, di indentare il codice, così da poterlo leggere più facilmente e più facilmente accorgersi di errori banali quali il parent mismatching o di malformazione di blocchi subordinati e annidati.
Ecco qualche approfondimento a riguardo.
E voi, di che indent style siete? Rispondete al sondaggio nella colonna a destra del blog!

organizzare il codice in librerie

nei quaderni c'e' un post a riguardo, a questo link.