Newsgroup: it.hobby.lotto
Titolo: Programmini riduzione compilati x Win

http://www.gnd.it/~fzellini/se/se.html

 
http://www.gnd.it/~fzellini/se/se.html
Dopo un po' di tempo che seguo il gruppo "nell'ombra" vorrei dire anche io
la mia riguardo alle riduzioni (io mi interesso solo al superenalotto ma
il principio e' lo stesso).
Premetto che sono un profano e capisco poco di matematica, tuttavia dopo
aver letto l'interessante articolo di Emanuele Cesena sulle riduzioni ho
provato anche io a scrivermi il mio programmino di riduzione in C proprio
come ha fatto Fabrizio (vedere la sua home page). Con mia grossa sorpresa
facendolo girare ho notato che ottiene gli stessi identici risultati di
tutti i programmini per win95 che ho provato recentemente (es. quelli di
MisterSoft, ma non solo). Per identici risultati intendo che ottengo lo
stesso numero di colonne del sistema ridotto a parita' di colonne integrali
di partenza e di garanzia voluta.
Allora mi sono chiesto se modificando l'integrale di partenza, il risultato
potesse cambiare, cioe' ad esempio invece di elaborare l'integrale dall'alto
verso il basso, lo si elaborasse dal basso verso l'alto. Ho apportato una
modifichina al mio programmino e, come supponevo, le cose cambiano e di molto!
Allora ho provato a spostare il punto di inizio di elaborazione in vari
modi e ogni volta lo stesso ridotto lo ottenevo con un numero di colonne
diverse, spesso molto minore.
Ora mi chiedo: esiste una legge matematica o anche un metodo empirico che
permetta di stabilire qual'e' il modo ideale di elaborare l'integrale di
partenza?
Se qualcuno ha qualche idea al riguardo si faccia sentire!
Allego il mio programmino C che gira sotto UNIX ma puo' essere compilato
penso dappertutto, vi avverto che l'ho scritto in un quarto d'ora quindi
sicuramente si puo' migliorare molto specie in quanto ad efficienza.
Per provare quello che ho detto sopra, lanciatelo cosi':
riduci [garanzia] [n.pronostici] [perc. perturbazione]
es. riduci 5 18 27   genera un ridotto garanzia 5 con 18 pronostici ed
                     inizia ad elaborare l'integrale dalla colonna che
                     corrisponde al 27% del totale
Saluti
Riccardo
----------- cut here for riduci.c ---------------------------------------
#include <stdio.h>
static void usage();
static int ndiff();
#define NC  1000000
static int np, gar;
static unsigned char bufc[NC][6];
static unsigned char bufr[NC][6];
void main(argc, argv)
int argc;
char **argv;
{
    unsigned char lv[6];
    static int nc, nrc;
    int i;
    int trid;
    int ridx = 1;
    int perturbation = 0;
    int npert;
    FILE *f;
    if  (argc < 3 || argc > 4)
        usage();
    gar = atoi(argv[1]);
    if  (gar < 2 || gar > 5)
        usage();
    if  (argc == 4) {
        perturbation = atoi(argv[3]);
        if  (perturbation > 100)
            usage();
    }
    trid = 6 - gar;
    np = atoi(argv[2]);
    printf("\n%d numeri, garanzia = %d\n\n", np, gar);
    printf("Generazione integrale in corso... "); fflush(stdout);
    for (lv[0] = 1; lv[0] <= np; lv[0]++)
        for (lv[1] = lv[0] + 1; lv[1] <= np; lv[1]++)
            for (lv[2] = lv[1] + 1; lv[2] <= np; lv[2]++)
                for (lv[3] = lv[2] + 1; lv[3] <= np; lv[3]++)
                    for (lv[4] = lv[3] + 1; lv[4] <= np; lv[4]++)
                        for (lv[5] = lv[4] + 1; lv[5] <= np; lv[5]++) {
                            memcpy(&bufc[nc++], &lv, 6);
                            if  (nc == NC)
                                break;
    }
    if  (nc == NC) {
        printf("\nIntegrale troppo grande, max %d colonne\n", NC);
        exit(1);
    }
    if  (perturbation) {
        npert = perturbation * nc / 100;
        memcpy(&bufr, &bufc, NC * 6);
        for (i = 0; i < nc - npert; i++)
            memcpy(&bufc[i], &bufr[i + npert], 6);
        for (i = 0; i < npert; i++)
            memcpy(&bufc[i + nc - npert], &bufr[i], 6);
        printf("\nTurbato integrale con offset = %d colonne\n", npert);
    }
    printf("\nRiduzione in corso...\n");
    while (1) {
        printf("\r Colonne ridotte: %d", ridx); fflush(stdout);
        for (i = 0; i < ridx; i++)
            memcpy(&bufr[nrc++], &bufc[i], 6);
        for (i = ridx; i < nc; i++) {
            if  (ndiff(&bufc[ridx - 1], &bufc[i]) > trid) {
                memcpy(&bufr[nrc++], &bufc[i], 6);
                if  (nrc == NC) {
                    printf("\nRidotto troppo grande, max %d colonne\n", NC);
                    exit(1);
                }
            }
        }
#ifdef 0
        printf("\n");
        for (i = 0; i < nrc; i++)
            printf("%02d-%02d-%02d-%02d-%02d-%02d\n",
                bufr[i][0], bufr[i][1], bufr[i][2],
                bufr[i][3], bufr[i][4], bufr[i][5]);
#endif
        if  (nrc == ridx)
            break;
        memcpy(&bufc, &bufr, NC * 6);
        memset(&bufr, 0x00, NC * 6);
        nc = nrc;
        nrc = 0;
        ridx++;
    }
    f = fopen("Sistemi/out", "w");
    printf("\nSistema ridotto (%d colonne):\n\n", nrc);
    for (i = 0; i < nrc; i++) {
        printf("%02d-%02d-%02d-%02d-%02d-%02d\n",
                bufr[i][0], bufr[i][1], bufr[i][2],
                bufr[i][3], bufr[i][4], bufr[i][5]);
        fprintf(f, "%02d-%02d-%02d-%02d-%02d-%02d\n",
                bufr[i][0], bufr[i][1], bufr[i][2],
                bufr[i][3], bufr[i][4], bufr[i][5]);
    }
    fclose(f);
}
static int ndiff(c1, c2)
char *c1, *c2;
{
    register int i, i2;
    int n = 0;
  for (i = 0; i < 6; i++) {  for (i2 = 0; i2 < 6; i2++) {  if  (c2[i] ==
c1[i2])  break;  }  if	(i2 == 6)  n++;  } #ifdef 0 
printf("%02d-%02d-%02d-%02d-%02d-%02d %02d-%02d-%02d-%02d-%02d-%02d  %d\n", 
c2[0], c2[1], c2[2], c2[3], c2[4], c2[5],  c1[0], c1[1], c1[2], c1[3], c1[4],
c1[5],	n); #endif  return(n); }
static void usage()
{
    printf("uso: riduci [garanzia] [numeri]\n");
    exit(1);
}
-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/
       Search, Read, Discuss, or Start Your Own    

pi...@adhoc.net
 ha scritto:
pan>  Ora mi chiedo: esiste una legge matematica o anche un metodo empirico che
pan>  permetta di stabilire qual'e' il modo ideale di elaborare l'integrale di
pan>  partenza?
forse sě, forse no :-)
pan>  Allego il mio programmino C che gira sotto UNIX ma puo' essere compilato
ma che splendore....
nel giro di pochi giorni 2 sorgenti completi per la riduzione: non si era mai
visto in questo NG, e guarda caso arrivano proprio da programmatori C e sotto
UNIX...strana coincidenza...:-)
viva C e unix!
Ciao
Marco
-- 
..Unix, MS-DOS, and Windows NT (also known as the Good, the Bad and the
Ugly). (Matt Welsh)

Per provare quello che ho detto sopra, lanciatelo cosi':
ho analizzato il tuo programma, ha un ordine di complessità esponenziale...
:-(((((
questo significa che ... per piccoli sistemi potrebbe andar bene... ma per
sistemi un pò più grandi non va bene!
richiederebbe tempi proibitivi per qualunque PC!
ha poi molte limitazioni... ma comunque ti faccio i miei complimenti! :-)
Ciao
P.S. io programmo sotto Windows in C++, ma non esiterei un attimo a cambiare
sistema operativo se ce ne fosse uno più diffuso!
--
Alessandro Pulvirenti
ale...@cedss.it

Un bel di' 
pi...@adhoc.net
 scrisse:
pan> aver letto l'interessante articolo di Emanuele Cesena sulle riduzioni ho
grazie, sono commosso :.-)
pan> Allora ho provato a spostare il punto di inizio di elaborazione in vari
pan> modi e ogni volta lo stesso ridotto lo ottenevo con un numero di colonne
pan> diverse, spesso molto minore.
Ottimo!! :-)
pan> Ora mi chiedo: esiste una legge matematica o anche un metodo empirico che
pan> permetta di stabilire qual'e' il modo ideale di elaborare l'integrale di
pan> partenza?
No, e' questo il bello... in teoria potresti provarle tutte... in pratica
non c'e' abbastanza tempo :-)
pan> Se qualcuno ha qualche idea al riguardo si faccia sentire!
Secondo me l'unico modo e' random, provando, provando ed ancora provando.
A questo proposito, avevo in mente un progettino, pero' mi serve tempo 
per svilupparlo... ve ne parlero' piu' avanti :-)
pan> Allego il mio programmino C che gira sotto UNIX ma puo' essere compilato
pan> penso dappertutto, vi avverto che l'ho scritto in un quarto d'ora quindi
pan> sicuramente si puo' migliorare molto specie in quanto ad efficienza.
pan> Per provare quello che ho detto sopra, lanciatelo cosi':
pan> 
ok
Ciao, e buono studio!!
-- 
"Espansione vuol dire complessita', e la complessita' tende a sgretolarsi",
terza legge di Parkinson
-- 
Emanuele Cesena
d.a.m...@iol.it
    occhio all'antispam NOSPAM!
http://www.geocities.com/SiliconValley/Grid/8879

Alessandro Pulvirenti ha scritto:
AP>  ho analizzato il tuo programma, ha un ordine di complessità esponenziale...
AP>  :-(((((
AP>  questo significa che ... per piccoli sistemi potrebbe andar bene... ma per
AP>  sistemi un pò più grandi non va bene!
AP>  richiederebbe tempi proibitivi per qualunque PC!
conosci algoritmi per la riduzione che abbiano complessità polinomiale o
inferiore? (esponenziale riferita alla quantità di combinazioni o di numeri in
pronostico?)
AP>  P.S. io programmo sotto Windows in C++, ma non esiterei un attimo a cambiare
AP>  sistema operativo se ce ne fosse uno più diffuso!
io programmo in C/C++/Java sotto linux, ma non esisterei un attimo a cambiare
sistema operativo se ce ne fosse uno migliore! :-)
Ciao
Marco
PS non te la prendere come al solito adesso :-)
-- 
Se hai un incarico complicato affidalo ad un pigro: troverà una maniera più
semplice di svolgerlo. (Legge di Hlade)

PS non te la prendere come al solito adesso :-)
non me la prendo... spero che da adesso in poi i prossimi messaggi siano in
un clima molto più pacifico... non ho nessuna intenzione di prendermela con
nessuno!
Ciao
--
Alessandro Pulvirenti
ale...@cedss.it

 richiederebbe tempi proibitivi per qualunque PC!
Avevo ben precisato che il programmino l'ho scritto in un quarto d'ora
mentre ero al lavoro, senza nessuna pretesa. Sicuramente e' limitato,
contiene errori, e puo' essere migliorato; l'ho postato solo a dimostrazione
di quello che avevo notato (cioe' che perturbando l'integrale di partenza
il risultato cambia).
Una cosa riguardo al programmino, anche se e' un poco off-topic -- io non ho
problemi di tempo di elaborazione,  perche' mentre calcolo la riduzione il
server fa tante altre cose e io pure :-)
Ciao
Riccardo


 forse sě, forse no :-)
Si o no? :-)
Se sai qualcosa, parla!
Un'altra cosa che non c'entra niente -- qualcuno, magari Emanuele :-),
conosce l'algoritmo per calcolare una riduzione ortogonale?
Siccome pare ci sia un po' di confusione sul significato di questo termine
per riduzione ortogonale io intendo quel tipo di riduzione che mi garantisce
la vincita anche se invece di indovinare 6 pronostici ne indovino solo 3 :-)
ciao
Riccardo


Alessandro Pulvirenti ha scritto:
AP>  pensavo che a chiunque guardasse il programma... fosse chiaro di che tipo di
AP>  complessita esponenziale stessi parlando! :-((
a dir la verità ho fatto un po' fatica a leggere quel codice e avevo avuto
l'impressione che fosse quadratica rispetto al numero di combinazioni, ma non
ho guardato più di tanto.
AP>  perchè pensi che ci sia qualcuno che programma in C++ e non sà programmare
AP>  in Java ? :-)
decisamente sì!
a parte alcune finezze sintattiche, la difficoltà principale sta nel conoscere
le varie librerie di supporto al linguaggio, senza le quali non fai molto. Le
API di java sono molte e in evoluzione.
AP>  guadagnare dal proprio lavoro... non si può permettere di fare scelte
AP>  diverse da quelle che vogliono la maggior parte delle persone... se no
AP>  rischia di morire di fame!
è un discorso moooolto lungo e OT per questo NG, anche se poi la conclusione,
nell'immediato, è corretta.
AP>  Dopo aver finito questo programma in C++ sotto Windows 95 o sup. inizierò lo
AP>  sviluppo in Java in modo da accontentare tutti...
evviva!
AP>  non me la prendo... spero che da adesso in poi i prossimi messaggi siano in
AP>  un clima molto più pacifico... non ho nessuna intenzione di prendermela con
AP>  nessuno!
idem!
Ciao
Marco
-- 
Risparmiate l'acqua. Fate la doccia con un amico. (Mae West)

> forse sě, forse no :-)
pan>  
pan>  Si o no? :-)
pan>  Se sai qualcosa, parla!
il problema della riduzione (non credo che troverai testi su come si riduce un
sistema, ma un sacco di testi su come partizionare in un certo modo un
insieme, rispettamndo certi criteri) č noto ai matematici e agli esperti di
ricerca operativa.
Io non sono nč uno nč l'altro :-( quindi non so dirti di piů.
Credo cmq, che si possa ricondurre ad un problema di Set Covering (ricopertura
di insieme) tra i tanti annessi e connessi.
pan>  Un'altra cosa che non c'entra niente -- qualcuno, magari Emanuele :-),
pan>  conosce l'algoritmo per calcolare una riduzione ortogonale?
ce ne saranno piů d'uno e cmq non ci sis riesce con ogni sistema, dipende
dalla struttura
pan>  per riduzione ortogonale io intendo quel tipo di riduzione che mi garantisce
pan>  la vincita anche se invece di indovinare 6 pronostici ne indovino solo 3 :-)
č ortogonale se, indovinando 3 numeri, hai _una_ e _una_ _sola_ combinazione
con i 3 numeri. Se ne hai piů di una non č piů ortogonale.
Ciao
Marco
-- 
L'ottimista proclama che viviamo nel migliore dei mondi possibili.
Il pessimista teme che sia vero.
(Teorema del Cardinale)

 con i 3 numeri. Se ne hai piů di una non č piů ortogonale.
e allora come si chiamano (e come si calcolano) quei sistemi che data una
certa garanzia di vincita con 6 pronostici indovinati, ti danno una garanzia
di vincita al 100% anche se indovini solo 3 numeri?
Ciao
Riccardo


Un bel di' 
pi...@adhoc.net
 scrisse:
pan> Un'altra cosa che non c'entra niente -- qualcuno, magari Emanuele :-),
ah ah ah... :-DD
secondo te cosa conosco!? :-DD
-- 
"1. Un funzionario vorra' sempre moltiplicare i suoi subordinati, non i rivali
 2. I funzionari creano lavoro l'uno per l'altro", assiomi di Parkinson


Un bel di' Marco Pozzato scrisse:
AP>>  perchè pensi che ci sia qualcuno che programma in C++ e non sà programmare
AP>>  in Java ? :-)
MP> decisamente sì!
MP> 
io :-)
P.S: pure il tuo TIN non scherza... :-D
(purtroppo mi si e' cancellata... dai, non ho voglia di andarla a prendere..)
-- 
"Tutte le grandi scoperte si fanno per sbaglio", legge di Young


Un bel di' 
pi...@adhoc.net
 scrisse:
pan> problemi di tempo di elaborazione,  perche' mentre calcolo la riduzione il
pan> server fa tante altre cose e io pure :-)
pan> 
forse non hai capito bene di *quanto* tempo si parla... :-DDD
-- 
"Se il proprio treno e' in ritardo, la coincidenza partira' in perfetto
orario", legge dei treni


 forse non hai capito bene di *quanto* tempo si parla... :-DDD
forse non hai capito bene che io non ho proprio fretta... :-)
Ciao
Riccardo


pi...@adhoc.net
 ha scritto:
pan>  e allora come si chiamano (e come si calcolano) quei sistemi che data una
pan>  certa garanzia di vincita con 6 pronostici indovinati, ti danno una garanzia
pan>  di vincita al 100% anche se indovini solo 3 numeri?
si chiamano sistemi ridotti N-3 (garantiscono il punteggio di categoria N-3,
dove N il punteggio massimo realizzabile)
I modi di calcolarli sono moltissimi perchè il problema è intrattabile, quindi
si ricorre ad algoritmi euristici. libera la fantasia....:-)
Ciao
Marco
ps non so e non mi interessa come si sviluppano, a parte qualche idea banale,
ma ben lontana dall'ottenere risultati spinti
-- 
I problemi piu' complessi hanno soluzioni semplici, facili da comprendere
e sbagliate. (Legge di Grossman)

> forse non hai capito bene di *quanto* tempo si parla... :-DDD
pan> 
pan> forse non hai capito bene che io non ho proprio fretta... :-)
pan> 
eh eh eh... a proposito di non aver fretta... si potrebbe fare un bel
programmino che va in esecuzione senza disturbare nessuno, e che
elabori, elabori, elabori... :-)
E quando trova un risultato migliore, cancella il vecchio e mette
quello.
Magari, evolvendolo un po', si potrebbe dividere il lavoro su diversi
client, che mandano, di tanto in tanto, i loro risultati al server...
...chissa' quali risultati si potrebbero ottenere :-)
-- 
"Qualsiasi sistema che dipende dall'inaffidabilita' umana e' inaffidabile",
legge di Gilb sull'Inaffidabilita'


Ema da TIN ha scritto:
EdT>  Magari, evolvendolo un po', si potrebbe dividere il lavoro su diversi
EdT>  client, che mandano, di tanto in tanto, i loro risultati al server...
questa stessa idea è stata usata anche per trovare la chiave di decodifica di
un algoritmo considerato ultrasicuro: scarichi un client e quando il tuo PC si
sta grattando i pollici, parte l'elaborazione. Mi pare che abbiamo già trovato
un paio di chiavi.
cmq, la parola magica per elaborazioni di questo tipo è PVM
Ciao
Marco
-- 
Il lavoro di equipe e' essenziale: ti permette di dare la colpa a qualcun
altro. (Ottava regola di Finangle)

Un bel di' Marco Pozzato scrisse:
MP> 
MP> cmq, la parola magica per elaborazioni di questo tipo è PVM
MP> 
Che significa...!? :-)
-- 
"Non discutere mai con un idiota: la gente potrebbe non notare la
differenza", prima legge del Dibattito


Ema da TIN ha scritto:
MP>> cmq, la parola magica per elaborazioni di questo tipo è PVM
MP>> 
EdT>  Che significa...!? :-)
Parallel Virtual Machine (almeno credo, a memoria....)
Non ricordo se sia programmabile solo in C o anche in altri linguaggi.
In pratica si tratta di una serie di librerie che consentono di scrivere
programmi che dovranno essere eseguiti su più macchine e gestiscono la
comunicazione e sincronizzazione tra le diverse istanze, come se si avesse un
unico computer parallelo.
Il tutto ha senso se e soltanto se il problema viene scomposto adeguatamente
per una computazione parallela.
Ad esempio: dovendo condizionare (per ogni singola combinazione occorre
stabilire se soddisfa certe condizioni) un sistema è possibile dare un po' di
combinazioni da controllare ad ognuna delle macchine disponibili, alla fine le
combinazioni buone verranno riaggregate su un'unica macchina.
Il risparmio in tempo dipende moltissimo da come è stato concepito
l'algoritmo: quanto più i sottoproblemi sono indipendenti tanto più si avrà
un'elaborazione efficiente. Se ho 4 macchine non potrei in nessun caso
impiegare un quarto del tempo: come minimo c'è sempre un minimo di
lavoro/tempo speso a sincronizzare le varie macchine e a riaggregare i
risultati dei sottoproblemi.
Certo è che avendo a disposizione 2 o 3 PC (magari pure vecchiotti) collegati
in rete locale ci si potrebbe divertire a fare esperimenti :-))
Ciao
Marco
-- 
Se vale la pena di farlo, ne valeva la pena ieri. (Dilemma di Grossman)

risultati dei sottoproblemi.
Finalmente mi è arrivato il Doppio Pentium II a 350 MHz.
Il secondo processore su Windows NT me lo sfrutta al 70% che è di più di
quanto mi aspettavo di ottenere.
Ciao
P.S. vediamo in quanti micro secondi mi effettua la sostituzione delle
quaterne in un sistema?! :-)))
--
Alessandro Pulvirenti
ale...@cedss.it

Alessandro Pulvirenti ha scritto:
AP>  Finalmente mi č arrivato il Doppio Pentium II a 350 MHz.
buon per te! :-)
AP>  Il secondo processore su Windows NT me lo sfrutta al 70% che č di piů di
AP>  quanto mi aspettavo di ottenere.
bhe, dipende moltissimo dalle applicazioni che ci usi sopra.
AP>  P.S. vediamo in quanti micro secondi mi effettua la sostituzione delle
AP>  quaterne in un sistema?! :-)))
perchč no? :-)
perň credo che dovresti scrivere un algortimo con uso abbondante di thread,
spezzando in due l'elaborazione, altrimenti non avresti un gran guadagno in
efficienza. Se ti prende lo sfizio di provarci, facci sapere.
Ciao
Marco
-- 
Non c'e' come oggi per rimandare quello che non si ha voglia di fare. 
(Quarta legge di Hecht)


Purtroppo non credo che con NT sia possibile fare quello che tu
dici. Secondo me la seconda CPU e' utilizzata solo nel caso che
si lancino piu' programmi contemporaneamente.
        Saluti

si lancino piu' programmi contemporaneamente.
io ho fatto una semplice compilazione (1 progr. solo in attività) con il Doppio Pentium II
a 350 MHz.
Risultati:
Windows 98 = 35 minuti (sfrutta una sola CPU)
Windows NT 4 = 21 minuti (sfrutta le due CPU)
Quindi anche se c'è un solo programma in esecuzione (compilatore) le CPU vengono sfruttate
entrambe!



La prova e' sicuramente interessante, pero' mi resta il dubbio, anche
se un tale divario mi sembra effettivamente troppo elevato,che la
differenza possa derivare non dall'utilizzo di 2 CPU, ma dalla maggiore
efficienza di NT rispetto a Windows 98. E' anche possibile che
in compilatore che tu usi sia progettato per sfruttare le 2 CPU.
Puoi confermarlo?
Potresti disabilitare una delle CPU e provare la stessa
compilazione con una sola?
        Saluti

compilazione con una sola?
devo vedere nel setup del PC!
Comunque la convenienza economica resta lo stesso dato che 2 CPU a 350 MHz costano poco di
più di 1 CPU a 400 MHz e meno di una a 450 MHz.
Le prestazioni di 2 CPU a 350 MHz (per non dire che si possono overcloccare... che per
adesso io preferisco non fare) sono meglio di una futura CPU a 700 MHz dato che il
raddoppio di frequenza non garantisce il raddoppio di prestazioni, la scheda madre sempre
a 100 MHz invia i dati, al max con quelle prossime future a 133 MHz.








Alessandro Pulvirenti ha scritto:
AP>  Quindi anche se c'è un solo programma in esecuzione (compilatore) le CPU vengono sfruttate
AP>  entrambe!
sei sicuro che il compilatore sia un unico processo?
voglio dire: è sì un unico eseguibile che tu lanci, ma questo normalmente
richiama altri eseguibili: preprocessore, linker, e tante altre belle amenità
dipendenti dal linguaggio e dall'ambiente.
spessissimo una compilazione lancia più processi in parallelo (ad esempio, c'è
nel make un opzione proprio per questo)
Infine: anche se si trattasse di un unico processo, questo potrebbe lanciare
più thread che si avvantaggerebbero delle CPU multiple. Non mi risulta che
Win98 abbia il supporto per il multiprocessing, mentre NT sì.
Ciao
Marco
-- 
Una falsità facile da capire e su cui si possa lavorare val più di una verità
complessa e incomprensibile. (Secondo postulato di Thumb)