A naso direi che il problema piu' grosso e' gestire la precisione anche del sorteggio e soprattutto la generazione dei numeri casuali, prestate attenzione a questo aspetto e probabilmente si puo' prendere spunto dalla generazione delle chiavi pubbliche.
Per il pi day io facevo anche pi greco song che mi affascina parecchio ...
Topic: Discussione sul pi greco - page 3. (Read 5321 times)
Non avevo capito il grado di complessità su cui volevo andare per quello te lo avevo fatto in PHP al volo.
Per quel che riguarda la velocità il PHP a sto punto non fa al caso tuo, rimane comunque troppo "lento".
Sicuramente per quello che devi fare le GPU sono perfette sfruttando le loro memorie interne e facendo tornare al programma principale direttamente il count.
Perfetto, allora qualcosa ci capisco Per quel che riguarda la velocità il PHP a sto punto non fa al caso tuo, rimane comunque troppo "lento".
Sicuramente per quello che devi fare le GPU sono perfette sfruttando le loro memorie interne e facendo tornare al programma principale direttamente il count.
Tranquillo che non voglio nulla, come detto erano 20 righe di codice... Se no non te lo postavo in chiaro! XD
Molto gentile, certo che è da 1 anno e mezzo che sono nel mondo bitcoin e non sono ancora riuscito ad acquistare/pagare nulla con i bitcoin 
!Per quel che riguarda le GPU invece non cambia il programma a seconda delle GPU ma del tipo di librerie che usi.
In particolare sulle GPU nVidia si programma in c usando CUDA, mentre sulle ati usando opencl.
Ma quindi mi confermi che i programmi che girano su nvidia non girano su ati e viceversa?In particolare sulle GPU nVidia si programma in c usando CUDA, mentre sulle ati usando opencl.
Posso provare nel week end a metterti giù un paio di righe su CUDA ma solo se poi tu hai questa tecnologia. Inoltre nel caso ti darei il sorgente c ma non ti saprei indicare come compilarlo su windows.
Ho a disposizione una nVidia Geforce GT 730, e quindi da questa pagina http://www.nvidia.it/object/geforce-gt-730-it.html#pdpContent=2 deduco che dovrei avere 96 core (o 384, non ho capito quale sia il mio modello)Non lo farei per il compenso ma per divertimento e interesse personale nel programmare con CUDA ma se ci riesco (e non è scontato, non ho molto tempo in questo periodo) poi sul come portarlo su windows sarebbe opera tua!
Io ero partito per fare questo lavoro per la scuola per il pi greco day, poi mi sono appassionato ben più del necessario (per i miei studenti dubito farà molta differenza se riuscirò a determinare una o due cifre decimali esatte in più 
) Ho scelto questo metodo per determinare pi greco perchè mi sembra molto semplice (noi matematici diremmo "elegante"), comprensibile e alla portata di tutti, anche se sono stati sviluppati altri metodi (ad esempio delle serie) che convergono a pi greco molto più rapidamente. Ma l'eleganza (e la possibilità per gli studenti di capire che cosa sta succedendo) vuole la sua parte...
Infine mi sono reso conto che l'algoritmo si prestava molto bene per essere parallelizzato, ma le mie competenze informatiche sono quelle che sono...
Grazie ancora!
Non avevo capito il grado di complessità su cui volevo andare per quello te lo avevo fatto in PHP al volo.
Per quel che riguarda la velocità il PHP a sto punto non fa al caso tuo, rimane comunque troppo "lento".
Tranquillo che non voglio nulla, come detto erano 20 righe di codice... Se no non te lo postavo in chiaro! XD
Per quel che riguarda le GPU invece non cambia il programma a seconda delle GPU ma del tipo di librerie che usi.
In particolare sulle GPU nVidia si programma in c usando CUDA, mentre sulle ati usando opencl.
Sicuramente per quello che devo fare le GPU sono perfette sfruttando le loro memorie interne e facendo tornare al programma principale direttamente il count.
Posso provare nel week end a metterti giù un paio di righe su CUDA ma solo se poi tu hai questa tecnologia. Inoltre nel caso ti darei il sorgente c ma non ti saprei indicare come compilarlo su windows.
Non lo farei per il compenso ma per divertimento e interesse personale nel programmare con CUDA ma se ci riesco (e non è scontato, non ho molto tempo in questo periodo) poi sul come portarlo su windows sarebbe opera tua!
Per quel che riguarda la velocità il PHP a sto punto non fa al caso tuo, rimane comunque troppo "lento".
Tranquillo che non voglio nulla, come detto erano 20 righe di codice... Se no non te lo postavo in chiaro! XD
Per quel che riguarda le GPU invece non cambia il programma a seconda delle GPU ma del tipo di librerie che usi.
In particolare sulle GPU nVidia si programma in c usando CUDA, mentre sulle ati usando opencl.
Sicuramente per quello che devo fare le GPU sono perfette sfruttando le loro memorie interne e facendo tornare al programma principale direttamente il count.
Posso provare nel week end a metterti giù un paio di righe su CUDA ma solo se poi tu hai questa tecnologia. Inoltre nel caso ti darei il sorgente c ma non ti saprei indicare come compilarlo su windows.
Non lo farei per il compenso ma per divertimento e interesse personale nel programmare con CUDA ma se ci riesco (e non è scontato, non ho molto tempo in questo periodo) poi sul come portarlo su windows sarebbe opera tua!
Un paio di osservazioni:
con il mio programmino, per poter ottenere 3,14152, cioè le prime 5 cifre decimali esatte, ho dovuto generare circa 500 miliardi di punti (circa 10 ore di lavoro-macchina)
Secondo i più esperti, parallelizzare il programma e farlo girare su una gpu invece che su una cpu incrementerebbe di molto la velocità? Immagino che in quel caso di sicuro aumenterebbe di molto anche la complessità del programma e si perderebbe inoltre in portabilità (schede video di marca diversa --> diverse implementazioni del programma), giusto?
con il mio programmino, per poter ottenere 3,14152, cioè le prime 5 cifre decimali esatte, ho dovuto generare circa 500 miliardi di punti (circa 10 ore di lavoro-macchina)
Secondo i più esperti, parallelizzare il programma e farlo girare su una gpu invece che su una cpu incrementerebbe di molto la velocità? Immagino che in quel caso di sicuro aumenterebbe di molto anche la complessità del programma e si perderebbe inoltre in portabilità (schede video di marca diversa --> diverse implementazioni del programma), giusto?
Grazie per le risposte!
Ho dato per scontato che mi contattaste prima di mettervi al lavoro, vi avrei dato qualche indicazione più precisa.
Mi serve :
- il multithread per una questione di ottimizzazione (sul mio portatile il mio programmino fa circa 1 miliardo di iterazioni al secondo)
- il tecnico di informatica della scuola in cui lavoro mi ha detto che i processori nella mia scuola sono quad-core, ciascuno con due thread, quindi potenzialmente posso fare un x 8 di incremento di velocità
- è importante che il programma gestisca variabile intere e reali molto grandi (devo poter generare anche mille miliardi di punti senza i limiti derivanti da variabili di tipo int o real)
- per davvo: penso che per lo scopo che mi prefiggo php non sia adatto perchè interpretato e quindi più lento (correggimi se sbaglio)
- per golikcoin: mi serve non solo l'eseguibile ma anche il sorgente per poter poi fare eventualmente anche delle modifiche e con l'occasione imparare poi a capire come funziona il multithread, (NB: il Pascal è il linguaggio che conosco e di cui ho già installato compilatore e ambiente di sviluppo, se mi proponi qualcos'altro tipo C ecc. se mi dai una mano a capire quali software su windows installare per poterlo compilare )
Quindi riassumendo:
- ringrazio davvo (inviami un tuo indirizzo e ti invio un piccolo riconoscimento per il lavoro svolto)
- chiedo a golikcoin : che linguaggio hai usato? il tuo programma contempla l'uso di variabili molto grandi? Mandami pure l'exe e poi ci mettiamo d'accordo sul compenso.
Grazie.
PS: il programma mi serve per sabato 14 marzo (mese 3, giorno 14, anno 15 --> 3,1415) giorno del "pi greco day" !
EDIT:
per golikcoin: dall'immagine del tuo programma l'algoritmo viene fatto girare 10 volte; a me servirebbe che l'algoritmo girasse anche 1 sola volta, ma che stampasse a video ogni x punti generati la stima parziale di pi greco (per poter così visualizzare il fatto che con il crescere dei punti generati migliora la stima);
quindi se ad esempio voglio generare 10 miliardi di punti con una stampa a video della stima ogni miliardo di punti , il programma dovrebbe:
- dividere il primo miliardo di punti da generare in 4 (ad esempio) thread da 250 milioni di punti ciascuno
- alla fine del primo ciclo aggiornare la variabile comune a tutti i thread: num_centri
- stampare la stima parziale di pi greco dopo il primo miliardo di punti
- quindi ridividere il secondo miliardo di punti in 4 thread, ....
- così fino al 10^ miliardo di punti
Ecco il mio programmino:
Ho dato per scontato che mi contattaste prima di mettervi al lavoro, vi avrei dato qualche indicazione più precisa.
Mi serve :
- il multithread per una questione di ottimizzazione (sul mio portatile il mio programmino fa circa 1 miliardo di iterazioni al secondo)
- il tecnico di informatica della scuola in cui lavoro mi ha detto che i processori nella mia scuola sono quad-core, ciascuno con due thread, quindi potenzialmente posso fare un x 8 di incremento di velocità
- è importante che il programma gestisca variabile intere e reali molto grandi (devo poter generare anche mille miliardi di punti senza i limiti derivanti da variabili di tipo int o real)
- per davvo: penso che per lo scopo che mi prefiggo php non sia adatto perchè interpretato e quindi più lento (correggimi se sbaglio)
- per golikcoin: mi serve non solo l'eseguibile ma anche il sorgente per poter poi fare eventualmente anche delle modifiche e con l'occasione imparare poi a capire come funziona il multithread, (NB: il Pascal è il linguaggio che conosco e di cui ho già installato compilatore e ambiente di sviluppo, se mi proponi qualcos'altro tipo C ecc. se mi dai una mano a capire quali software su windows installare per poterlo compilare
)Quindi riassumendo:
- ringrazio davvo (inviami un tuo indirizzo e ti invio un piccolo riconoscimento per il lavoro svolto)
- chiedo a golikcoin : che linguaggio hai usato? il tuo programma contempla l'uso di variabili molto grandi? Mandami pure l'exe e poi ci mettiamo d'accordo sul compenso.
Grazie.
PS: il programma mi serve per sabato 14 marzo (mese 3, giorno 14, anno 15 --> 3,1415) giorno del "pi greco day"
! EDIT:
per golikcoin: dall'immagine del tuo programma l'algoritmo viene fatto girare 10 volte; a me servirebbe che l'algoritmo girasse anche 1 sola volta, ma che stampasse a video ogni x punti generati la stima parziale di pi greco (per poter così visualizzare il fatto che con il crescere dei punti generati migliora la stima);
quindi se ad esempio voglio generare 10 miliardi di punti con una stampa a video della stima ogni miliardo di punti , il programma dovrebbe:
- dividere il primo miliardo di punti da generare in 4 (ad esempio) thread da 250 milioni di punti ciascuno
- alla fine del primo ciclo aggiornare la variabile comune a tutti i thread: num_centri
- stampare la stima parziale di pi greco dopo il primo miliardo di punti
- quindi ridividere il secondo miliardo di punti in 4 thread, ....
- così fino al 10^ miliardo di punti
Ecco il mio programmino:
se vuoi ti ho fatto un exe, semplice sepmlice non so se sia corretto cmq questo è l'output
questa l'interfaccia
se è corretto rispondi pure qui che ti mando diretto l'exe
Quote
Stima di Pi greco dopo 100000 punti: 3,14704
Stima di Pi greco dopo 100000 punti: 3,14456
Stima di Pi greco dopo 100000 punti: 3,14264
Stima di Pi greco dopo 100000 punti: 3,14028
Stima di Pi greco dopo 100000 punti: 3,14708
Stima di Pi greco dopo 100000 punti: 3,14616
Stima di Pi greco dopo 100000 punti: 3,14548
Stima di Pi greco dopo 100000 punti: 3,14284
Stima di Pi greco dopo 100000 punti: 3,13924
Stima di Pi greco dopo 100000 punti: 3,14612
Valore esatto Pi greco: 3,14159265355
Stima di Pi greco dopo 100000 punti: 3,14456
Stima di Pi greco dopo 100000 punti: 3,14264
Stima di Pi greco dopo 100000 punti: 3,14028
Stima di Pi greco dopo 100000 punti: 3,14708
Stima di Pi greco dopo 100000 punti: 3,14616
Stima di Pi greco dopo 100000 punti: 3,14548
Stima di Pi greco dopo 100000 punti: 3,14284
Stima di Pi greco dopo 100000 punti: 3,13924
Stima di Pi greco dopo 100000 punti: 3,14612
Valore esatto Pi greco: 3,14159265355
questa l'interfaccia
se è corretto rispondi pure qui che ti mando diretto l'exe
Non ho capito sinceramente se lo volevi per forza in pascal o ti andava bene qualsiasi linguaggio.
Ora, se lo volevi in pascal passo, non è il mio linguaggio.
Se ti va bene in altro (vedi php) ti ho messo giù una bozza.
Certo, non è ottimizzata nella comunicazione tra i thread (scrivono su un file alla fine, non proprio bello ma funzionale).
Il programma sembra funzionare e sfrutta tutte le cpu di cui disponi in modo parallelo per fare la "pioggia" di puntini all'interno del quadrato. Ogni thread fa la sua pioggia e poi si sommano i valori.
Il codice è il seguente, commentato, dovrebbe esser semplice da capire:
$approx_decim = 10000000; // Approssimazione dei numeri, con 10 i punti vanno da 0.0 a 1.0 mentre con 100 uso due cifre decimali e cosi via
$num_punti = 10000000; // Numero di punti (pioggia) che ogni thread deve generare
$num_thread = 4; // Numero di thread da usare
$tot = 0; // Totale dei punti interni
for ($i = 1; $i <= $num_thread; ++$i) {
// Genero i figli
$pid = pcntl_fork();
if (!$pid) {
// Per ogni figlio chiamo la funzione
$tmp = calcola($num_punti, $approx_decim);
// E scrivo il risultato su file
file_put_contents("result.txt", "$tmp*", FILE_APPEND | LOCK_EX);
exit($i);
}
}
// Aspetto la fine di tutti i figli
echo "Ho lanciato tutti i figli, aspetto la fine....\n";
while (pcntl_waitpid(0, $status) != -1) {
$status = pcntl_wexitstatus($status);
echo "Figlio numero $status terminato\n";
}
// Quando ogni figlio ha finito
echo "Hanno finito tutti i figli, faccio la somma...\n";
// Leggo il contenuto del file
$tmp = file_get_contents("result.txt");
// Cancell il file
unlink("result.txt");
// Divido il file in array
$tmp = explode("*", $tmp);
// Elimino l'ultimo elemento che e' sempre vuoto
array_pop($tmp);
// Stampo i risultati di ogni thread
echo "\nPer ogni thread questi sono i punti interni:\n";
print_r($tmp);
// Sommo i punti interni di ogni thread (quelli esterni sono ugauli a $num_thread per $num_punti
foreach($tmp as $v)
$tot += $v;
// Calcolo pigreco
$pig = 4*$tot/($num_thread*$num_punti);
// Ti stampo il risultato mettendo un speratore di centinaia nel numero di thread per bellezza :)
echo "\nValore esatto Pi greco dopo ".number_format(($num_thread*$num_punti),0,"",".")." di cui interi ".number_format($tot,0,"",".")." viene $pig\n";
// Alla funzione passo quanti punti calcolare (prima parametro) e l'appossimazione decimale (con 100 i punti interni vanno da 0.00 a 1.00)
function calcola($num_punti, $approx_decim){
$num_centri = 0;
for($i = 0; $i < $num_punti; $i++){
$x = rand(0, $approx_decim) / $approx_decim;
$y = rand(0, $approx_decim) / $approx_decim;
if ((($x*$x)+($y*$y)) < 1.0)
$num_centri += 1;
}
return $num_centri;
}
?>
Come detto, dove lo lanci crea un file result.txt in cui scrivo i vari risultati.
Basta che lo prendi, lo salvi su un qualsiasi server unix (windows è più complicato da usare come thread per php) e lo lanci con php5-cli.
L'output che genera è il seguente:
Ora, se lo volevi in pascal passo, non è il mio linguaggio.
Se ti va bene in altro (vedi php) ti ho messo giù una bozza.
Certo, non è ottimizzata nella comunicazione tra i thread (scrivono su un file alla fine, non proprio bello ma funzionale).
Il programma sembra funzionare e sfrutta tutte le cpu di cui disponi in modo parallelo per fare la "pioggia" di puntini all'interno del quadrato. Ogni thread fa la sua pioggia e poi si sommano i valori.
Il codice è il seguente, commentato, dovrebbe esser semplice da capire:
Code:
$approx_decim = 10000000; // Approssimazione dei numeri, con 10 i punti vanno da 0.0 a 1.0 mentre con 100 uso due cifre decimali e cosi via
$num_punti = 10000000; // Numero di punti (pioggia) che ogni thread deve generare
$num_thread = 4; // Numero di thread da usare
$tot = 0; // Totale dei punti interni
for ($i = 1; $i <= $num_thread; ++$i) {
// Genero i figli
$pid = pcntl_fork();
if (!$pid) {
// Per ogni figlio chiamo la funzione
$tmp = calcola($num_punti, $approx_decim);
// E scrivo il risultato su file
file_put_contents("result.txt", "$tmp*", FILE_APPEND | LOCK_EX);
exit($i);
}
}
// Aspetto la fine di tutti i figli
echo "Ho lanciato tutti i figli, aspetto la fine....\n";
while (pcntl_waitpid(0, $status) != -1) {
$status = pcntl_wexitstatus($status);
echo "Figlio numero $status terminato\n";
}
// Quando ogni figlio ha finito
echo "Hanno finito tutti i figli, faccio la somma...\n";
// Leggo il contenuto del file
$tmp = file_get_contents("result.txt");
// Cancell il file
unlink("result.txt");
// Divido il file in array
$tmp = explode("*", $tmp);
// Elimino l'ultimo elemento che e' sempre vuoto
array_pop($tmp);
// Stampo i risultati di ogni thread
echo "\nPer ogni thread questi sono i punti interni:\n";
print_r($tmp);
// Sommo i punti interni di ogni thread (quelli esterni sono ugauli a $num_thread per $num_punti
foreach($tmp as $v)
$tot += $v;
// Calcolo pigreco
$pig = 4*$tot/($num_thread*$num_punti);
// Ti stampo il risultato mettendo un speratore di centinaia nel numero di thread per bellezza :)
echo "\nValore esatto Pi greco dopo ".number_format(($num_thread*$num_punti),0,"",".")." di cui interi ".number_format($tot,0,"",".")." viene $pig\n";
// Alla funzione passo quanti punti calcolare (prima parametro) e l'appossimazione decimale (con 100 i punti interni vanno da 0.00 a 1.00)
function calcola($num_punti, $approx_decim){
$num_centri = 0;
for($i = 0; $i < $num_punti; $i++){
$x = rand(0, $approx_decim) / $approx_decim;
$y = rand(0, $approx_decim) / $approx_decim;
if ((($x*$x)+($y*$y)) < 1.0)
$num_centri += 1;
}
return $num_centri;
}
?>
Come detto, dove lo lanci crea un file result.txt in cui scrivo i vari risultati.
Basta che lo prendi, lo salvi su un qualsiasi server unix (windows è più complicato da usare come thread per php) e lo lanci con php5-cli.
L'output che genera è il seguente:
Code:
root@x:/tmp$ php pigreco.php
Ho lanciato tutti i figli, aspetto la fine....
Figlio numero 3 terminato
Figlio numero 4 terminato
Figlio numero 1 terminato
Figlio numero 2 terminato
Hanno finito tutti i figli, faccio la somma...
Per ogni thread questi sono i punti interni:
Array
(
[0] => 7853664
[1] => 7854466
[2] => 7853005
[3] => 7854225
)
Valore esatto Pi greco dopo 40.000.000 di cui interi 31.415.360 viene 3.141536
Ho lanciato tutti i figli, aspetto la fine....
Figlio numero 3 terminato
Figlio numero 4 terminato
Figlio numero 1 terminato
Figlio numero 2 terminato
Hanno finito tutti i figli, faccio la somma...
Per ogni thread questi sono i punti interni:
Array
(
[0] => 7853664
[1] => 7854466
[2] => 7853005
[3] => 7854225
)
Valore esatto Pi greco dopo 40.000.000 di cui interi 31.415.360 viene 3.141536
Cerco un programmatore disposto a modificare (o sarebbe meglio dire a riscrivere 
) un mio piccolissimo programmino (< 100 righe di codice!). Ovviamente pago in btc.
Il programmino in questione non c'entra nulla con il mondo bitcoin, è una semplice implementazione del metodo Monte Carlo per la stima del valore di pi greco.
L'idea è molto semplice, il programma genera dei "punti" casuali nel primo quadrante del piano cartesiano (una coppia di variabili pseudo-casuali comprese tra 0 e 1). Tutti questi punti quindi cadono necessariamente in un quadrato immaginario di vertici (0,0),(1,0),(1,1),(0,1). Poi il programma calcola quanti di questi punti cadono anche nel settore circolare (x^2 + y^2 <= 1,x>=0, y>=0). Se genero molti punti, il rapporto tra il numero di punti che cadono nel quarto di cerchio e quelli totali che cadono nel quadrato è all'incirca uguale al rapporto tra le aree delle due figure, cioè pigreco / 4.
Qui di seguito l'algoritmo di base del programma (è in Pascal):
Il programma di per sè funziona, volevo farne però una versione "multithread"*; non mi intendo affatto di questa tecnica di programmazione e per questo chiedo l'aiuto di qualcuno che se ne intenda.
(*Ho dato un'occhiata a questo http://wiki.freepascal.org/Multithreaded_Application_Tutorial e ho capito che non ho il tempo/voglia di studiarmi da solo la cosa).
Grazie.
) un mio piccolissimo programmino (< 100 righe di codice!). Ovviamente pago in btc.Il programmino in questione non c'entra nulla con il mondo bitcoin, è una semplice implementazione del metodo Monte Carlo per la stima del valore di pi greco.
L'idea è molto semplice, il programma genera dei "punti" casuali nel primo quadrante del piano cartesiano (una coppia di variabili pseudo-casuali comprese tra 0 e 1). Tutti questi punti quindi cadono necessariamente in un quadrato immaginario di vertici (0,0),(1,0),(1,1),(0,1). Poi il programma calcola quanti di questi punti cadono anche nel settore circolare (x^2 + y^2 <= 1,x>=0, y>=0). Se genero molti punti, il rapporto tra il numero di punti che cadono nel quarto di cerchio e quelli totali che cadono nel quadrato è all'incirca uguale al rapporto tra le aree delle due figure, cioè pigreco / 4.
Qui di seguito l'algoritmo di base del programma (è in Pascal):
Code:
for i:=1 to num_punti do
begin
x:= random ;
y:= random ;
if (x*x+y*y<1.0) then num_centri:=num_centri+1;
end;
num_centri_reale:=num_centri;
num_punti_reale:=num_punti;
stima_pi_greco:=4.0*num_centri_reale/num_punti_reale;
writeln('');
writeln('Stima di Pi greco dopo ',i,' punti: ', stima_pi_greco:1:9);
pi_greco:=3.1415926535;
writeln('Valore esatto Pi greco: ', pi_greco:1:9);
begin
x:= random ;
y:= random ;
if (x*x+y*y<1.0) then num_centri:=num_centri+1;
end;
num_centri_reale:=num_centri;
num_punti_reale:=num_punti;
stima_pi_greco:=4.0*num_centri_reale/num_punti_reale;
writeln('');
writeln('Stima di Pi greco dopo ',i,' punti: ', stima_pi_greco:1:9);
pi_greco:=3.1415926535;
writeln('Valore esatto Pi greco: ', pi_greco:1:9);
Il programma di per sè funziona, volevo farne però una versione "multithread"*; non mi intendo affatto di questa tecnica di programmazione e per questo chiedo l'aiuto di qualcuno che se ne intenda.
(*Ho dato un'occhiata a questo http://wiki.freepascal.org/Multithreaded_Application_Tutorial e ho capito che non ho il tempo/voglia di studiarmi da solo la cosa).
Grazie.
Jump to: