Newsgroup: it.comp.lang.c++
Titolo: Numeri PseudoCasuali

Devo fare un programma di simulazione e, ovviamente, mi serve generare
numeri casuali (o per lo meno pseudocasuali).  Avevo intenzione di
usare qualche funzione standar, magari rand () ma il mio problema č
che necessito di volta in volta di un limite ai numeri da generare
(per esempio mi serve di generare numeri dallo 0 al 5 oppure dallo 0
al 10, numeri relativamente bassi). 
Come posso fare?
C'č qualche altro algoritmo di facile implementazione e dai buoni
risultati? 
grazie 
messaggio di: cred [
cre...@infinito.it
]

 Come posso fare?
per un numero da 0 a 5 basta fare rand()%6
Pela

 ha scritto:

Attento, quel '%' può far scatenere delle guerre, ma ormai, forse, è
troppo tardi.
Ciao
-- 
Abruzzo Silvio
studente,  16 anni
goku_...@libero.it
silvi...@aruba.it
 <--- old e-mail address
Linux Machine : 219721
ICQ number : 130839630
http://utenti.tripod.it/abruzzosilvio/
^___^

:

Solo? °__°
messaggio di: cred [
cre...@infinito.it
]

Quella operazione produce delle sequenze casuali di numeri molto poco
casuali.
Usa questa:
#define MyRand(max) (int) rand()%max //((max*rand())/(1.0 + RAND_MAX))
Ciao!
Dome
--
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
PC Brain Official Web Site
http://digilander.iol.it/pcbrain
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-



Siete OT, scambiarvi delle e-mail private costa troppo?
Questo newsgroup si occupa del linguaggio C++ in quanto tale, e non di
aspetti specifici di particolari implementazioni. Per questo non e' il
posto piu' adatto per porre domande specifiche come la tua.
Potresti avere piu' fortuna su uno dei seguenti gruppi:
Per Win32 (95, 98, NT): it.comp.programmare.win32
Per Dos/Win 3.x: it.comp.os.dos
Per Linux:      it.comp.os.linux.development
Per C++Builder: i gruppi borland.public.cppbuilder.*, disponibili sul
                server 
newsgroups.borland.com
 (prevalentemente in 
                inglese, ma si puo' postare anche in italiano)
Grazie.
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Siete OT, scambiarvi delle e-mail private costa troppo?
Sei TONTO allora... 8/
-- 
Luc.

 Luc.
Be ci sei tu che compensi.
Ripeto: lo hai letto il manifesto ?


Solo? °__°
In "Numerical Recipes in C, the art of scientific calculation" è consigliato
di fare, invece, qualcosa di questo tipo:
(int) (6.0*rand()/(RAND_MAX+1.0))   
Sia chiaro, cito semplicemente una fonte. Io non ho mai verificato 
personalmente quale dei 2 metodi funziona meglio, ma uso il secondo.
Non voglio scatenare guerre  :^)
--
Davide Cavallari

Ragazzi, avete rotto!
In NESSUN NG rompono le palle con l'OT quanto qui!
E guarda che di solito sono uno dei primi a dire quando si č OT. ORA NO!
Il manifesto NON nega di scambiarsi opinioni su algoritmi!
Non diciamo cavolate!
Dome

Ragazzi, avete rotto!
Il problema non è tanto su rand ma sul fatto che da queste discussioni
si generino sempre discussioni OT.
-- 
Marco Barisione (ICQ 84277092)

 In NESSUN NG rompono le palle con l'OT quanto qui!
Ci daranno il premio.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 


Hai ragione. Scambiarsi indicazioni su come implementare algoritmi in
C++ e' assolutamente in argomento. Disquisizioni sui meriti relativi di
diversi generatori pseudo-casuali lo sarebbe meno, ma in questo thread
non ci siamo ancora arrivati.
Ciao,
Nicola
P.S. Se hai letto alcuni lunghi e noiosi thread sull'argomento, sai da
dove viene l'agitazione dei nostri compagni di newsgroup, che farebbero
comunque bene a darsi una calmata.

 Dome
si ci sarà un bel 0,000003 % di OT
è intollerabile :))))))
--
-------
sito: 
www.dadev.it
ultime: Ocx per irc testi freeware
-------

(int) (6.0*rand()/(RAND_MAX+1.0))   
Grazie per entrambe le risposte, sceglierň quello che č piů idoneo al
mio caso..
messaggio di: cred [
cre...@infinito.it
]

                inglese, ma si puo' postare anche in italiano)
Mi sembrava che un gruppo sul C++ fosse il posto più idoneo per
discutere della funzione 'rand()' che è standar del C++...  
messaggio di: cred [
cre...@infinito.it
]

 #define MyRand(max) (int) rand()%max //((max*rand())/(1.0 + RAND_MAX))
questa qua sopra fa esattamente la stessa cosa; forse non hai notato ma la 
parte interessante e' commentata! Inoltre e' fortemente sconsigliato l'uso 
delle macro, anche considerando che in C++ ci sono degli strumenti che le 
rendono inutili in molti casi; infine dovresti mettere tra parentesi 
l'argomento della macro ( rand() % (max) ).
In ogni caso alla macro qua sopra e' preferibile:
inline int MyRand(int max) { return max*rand()/(1.0 + RAND_MAX); }
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

Verissimo, pardon, ho solo copiato la macro dai sorgenti di un mio programma
scritto in C!


 ma in questo thread non ci siamo ancora arrivati.
E forse non ci arriveremo perché "credici" sembra soddisfatto delle risposte
ricevute e ha detto che userà il metodo più idoneo al suo caso.
Premettendo e sottolineando che non ho alcuna intenzione di giudicare e
offendere l'operato di "credici", vorrei un tuo parere: lui, nel suo
programma di simulazione, userà un pessimo sistema per ottenere numeri
pseudocasuali entro un dato intervallo generati da un pessimo o mediocre
generatore ed è molto probabile che non se ne renda conto perché non si è
mai interessato all'argomento. Ed è anche molto probabile, invece, che a
"credici" piacerebbe usare un gran bel generatore ed un sistema impeccabile
per ottenere i suoi numeri nel programma di simulazione che lui ha scritto
con passione ed entusiasmo.
Non ritieni che tentare di fargli capire cosa sta facendo sia
*perfettamente* in argomento  prescindendo dall'osservanza pedissequa del
manifesto del ng?
Non ritieni che il problema sorga *esclusivamente* quando gl'incompetenti
assoluti vogliono aver ragione a tutti i costi in merito ad argomenti del
tutto estranei ai loro interessi?
"Ma chi mi dice che Cristiano non sia un idiota d'un lamer?" potrebbe essere
l'ovvia quanto lecita domanda.
In primo luogo, chiunque sia esente da deficit psichici può verificare
quanto asserisco consultando i vagoni di documenti sparsi per tutto il web;
secondo, nella speranza di non sembrare un vanaglorioso, posso dire d'aver
iniziato quasi tre anni fa ad interessarmi a tempo pieno all'argomento e ho
generato e testato centinaia di miliardi di numeri generati da decine di
algoritmi sia consolidati che di mia invenzione. Come sono stato in grado di
scovare alcuni bug nel noto test diehard del grande Marsaglia e nel test del
NIST americano, ritengo di essere almeno in grado di dare qualche
suggerimento di base se non altro scaturito dalle molte migliaia di test
effettuati.
A prescindere da tutto, comunque devi aver notato dagli ultimi thread che ho
deciso di non dare più spago ai lamer, per cui, in teoria, la quiete del ng
non dovrebbe più essere turbata dai numeri casuali.
Saluto tutti scusandomi per la lunghezza di questo post "filosofico" :-)
Cristiano

 Saluto tutti scusandomi per la lunghezza di questo post "filosofico" :-)
Ecco, mi hai tirato fuori quello che penso di tutta la storia. Spero che
non venga mai piu' riaperta.
Ciao,
Nicola

 discutere della funzione 'rand()' che è standar del C++...
Infatti. Solo che siccome in passato su questo argomento si sono
scatenate delle penosissime flame war, gli animi sono un po'
suscettibili.
Ciao,
Nicola


ma è posisbile che tra persone adulte non si possa parlare di rand() ??
bisogna litigare per cose così assurde?
e poi ci lamentiamo se fanno guerre per stupidate..
mah


 non venga mai piu' riaperta.
Io non ho interessi particolari per continuare a postare qui e il mio
carattere non mi consente di portare avanti un'azione di disturbo contro la
mia volontà. Per cui rassicuro tutti dicendo che questo è il mio ultimo post
qui.
Mi rammarico solo del fatto che ultimamente non si sia riusciti a imbastire
conversazioni interessanti sui numeri casuali.
Rinnovo il saluto a tutti (anche al Griffini :-) ) e buon proseguimento.
Cristiano

 poi dice che vanno bene?
Puo' anche essere. Tu non lo sai.
Cerco di spiegartelo in altri termini facendo un paragone: quando puoi dire che
un certo algoritmo e' sufficientemente ottimizzato?
Risposta: quando e' veloce a sufficienza per il problema che devi risolvere.
Se il tuo problema consiste nell'ordinare 10 numeri interi in meno di 3 minuti,
qualunque algoritmo di sort per te' e sufficientemente ottimizzato. Non ha senso
dire che il quicksort (algoritmo che risulta il piu' veloce nella maggior parte
dei casi pratici in cui serve fare un sort) e' intrinsecamente meglio del
bubblesort (algoritmo che risulta il piu' lento nella maggior parte dei casi
pratici in cui serve fare un sort). E non e' neppure sensato dire che per 10
numeri un selection sort e' l'algoritmo piu' veloce per ordinare 10 interi. Per
quanto questo sia vero, qualunque algoritmo ci sia a disposizione e' il migliore
per il tuo problema. Ed e' il migliore per il semplice fatto che e' a
disposizione.
In molti casi il problema che richiede il numero casuale e' tale che non frega
nulla che il numero sia effettivamente casuale secondo un qualunque test
statistico. In questi casi il vantaggio fornito da un algoritmo di quelli che tu
chiameresti "seri" e' talmente minimale che e' inferiore allo svantaggio di
dover editare la command line del linker, o del compilatore, o il file make o
quant'altro, per includere una nuova libreria o un qualunque cosa serva per
inserire quell'algoritmo. Sia anche solo il fastidio di aprire un file che tieni
sul desktop per fare il cut&paste di tre linee di codice che implementano la
formula che usi per calcolare il prossimo numero della sequenza.
Qundi in tutti i problemi in cui la casualità della sequenza non ha alcuna
importanza, l'algoritmo migliore e' quello che e' gia' a disposizione. E in
C/C++ questo e' dato da rand().
Tu sembri pensare che se ti serve una sequenza numerica qualunque allora ti
serve una sequenza numerica casuale. Sbagli. Non e' cosi'.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 che li supera.
Si, ma se io ho i test A B C D e E.
Il primo generatore supera A C D e E
Il secondo supera B.
Allora il primo è migliore  del secondo... ma se il mio scopo è ottenere
numeri casuali come quelli del test B?
Ciao
--
Luigi
byte...@hotmail.com
http://web.tiscali.it/luigi_web
ICQ #46240443

> Ed e' il migliore per il semplice fatto che e' a disposizione.
Mica spesso....


 Sei TONTO allora... 8/
Hai capito ora vista l'evoluzione di questo tred ?
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 


 inline int MyRand(int max) { return max*rand()/(1.0 + RAND_MAX); }
 
Ciao.
Ho provato ad applicare questa funzione ma mi da tutti zeri!!!
Non capisco dove possa essere l'inghippo:
#include <iostream>
#include <cstdlib>
#include <unistd.h>
inline int Mrand(int max) { return max*rand() / (1.0+RAND_MAX); }
int main(void)
{
int i;
 srand(getpid()*50);
        for(i=0; i<10; i++)
        {
        cout<<Mrand(10)<<endl;
        }
}
Risultato: 10 zeri!
Qualche idea? Grazie.
-- 
"A pensar male si pecca, ma spesso ci s'azzecca..."
Saluti 	 		      << Linux Powered >>			 
LIBRA               e-mail: metti "libero" al posto di "NOSPAM"  

 Non capisco dove possa essere l'inghippo:
Io l'ho provata con il mio compilatore (C++ Builder 3.0), e funziona
benissimo; sicuro di non aver messo uno 0 al posto del 10 all'interno
del ciclo for (Mrand(0) dà sempre 0) ? 
Cecco

 del ciclo for (Mrand(0) dà sempre 0) ? 
Sicurissimo. Il codice l'ho copiato pari pari, e non funziona.
Io uso il g++


 non venga mai piu' riaperta.
Io non ho interessi particolari per continuare a postare qui e il mio


 inline int Mrand(int max) { return max*rand() / (1.0+RAND_MAX); }
colpa mia; avevo trasformato la macro di DOM3 in una funzione inline, ma 
non mi ero preoccupato di vedere se era corretta. In effetti e' 
completamente sbagliata! Guarda questa, che dovrebbe funzionare:
inline int MyRand(int max) { 
        return max * static_cast<int>( (double)rand()/RAND_MAX );
}
(spero di non aver fatto qualche casino con le parentesi...)


 }
inline int Mrand(int max) 
{ return max * static_cast<int> ( (double)rand()/ (1.0+ RAND_MAX)); }
L'ho scritta cosi' (le parentesi dovrebbero essere giuste).......ma non
funziona: sempre zeri! sia che divida per RAND_MAX che per RAND_MAX + 1.
Me lo sento che mi sta sfuggendo una ca%%atina, ma non riesco a
trovarla.


 Hai capito ora vista l'evoluzione di questo tred ?
...
-- 
Luc.

----- Original Message ----- 
From: "Luc" <XXX...@katamail.comXXX>
Newsgroups: it.comp.lang.c++


Elasticita' nulla.
Hai capito ora vista l'evoluzione di questo thread ?


 Hai capito ora vista l'evoluzione di questo thread ?
Ripeto:
...
Spiego:
Lasciamo perdere...
-- 
Luc.

 trovarla.
Provate a scriverla cosi':
inline int Mrand(int max)
{
    return max * static_cast<double>(rand()) / (1.0+ RAND_MAX);


 }
BINGO!
Cosi' funziona. Mi da solo un warning in fase di compilazione:
casual.cxx: In function `int Mrand(int)':
casual.cxx:11: warning: return to `int' from `double'
Grazie mille a tutti.


 casual.cxx:11: warning: return to `int' from `double'
Casta:
return int(max * static_cast<double>(rand()) / (1.0+ RAND_MAX));
-- 
Luc.

 return int(max * static_cast<double>(rand()) / (1.0+ RAND_MAX));
Perfetto!
E' inutile, il cast non mi entrera' mai in testa :(
Grazie.


 casual.cxx:11: warning: return to `int' from `double'
Se ti da fastidio il warning fai cosi':
inline int Mrand(int max)
{
    return static_cast<int>(max * static_cast<double>(rand()) / (1.0+
RAND_MAX));


 funziona: sempre zeri! sia che divida per RAND_MAX che per RAND_MAX + 1.
cavolo, hai ragione! Sono io che sono completamente rinco***nito :-(. 
Sposta la moltiplicazione per max all'interno del cast:
        return static_cast<int>( (double)rand()*max/ RAND_MAX);


 }
Un altro paio di cast e il return si editava in 3-4 righe da 80 colonne... 8)
int(...) non è più comodo?
-- 
Luc.

> int(...) non è più comodo?
Ma static_cast<int> è più C++ :)


 Ma static_cast<int> è più C++ :)
Ma in questo caso sono 11 caratteri 'inutili' in più nel sorgente...
-- 
Luc.

 int(...) non è più comodo?
Si. Ma meno C++. Comunque se hai problemi di usura della tastiera questa e'
perfettamente equivalente:
inline int Mrand(int max) { return int(max*(double)rand()/(1.0+RAND_MAX)); }


 inline int Mrand(int max) { return int(max*(double)rand()/(1.0+RAND_MAX)); }
Parlavo piů in generale di usare il costrutto 'static_cast<>' piů volte nella 
stessa linea di codice, rendendolo di difficile lettura...
-- 
Luc.


Strano, con il BCC 5.5 mi funziona.
Prova con
inline int Mrand(int max) { return max * (rand() / (1.0+RAND_MAX)); }
Infatti il cast esplicito a double di rand() (come suggerito negli altri post)
dovrebbe essere inutile, in quanto 1.0 č un double; quindi il compilatore mette
in moto le conversioni implicite.
Ciao  Manlio Perillo

 Grazie.
Prova a fare
return (max * static_cast<double>(rand()) / (1.0+ RAND_MAX));
Dovrebbe essere inutile specificare int in quanto è il tipo
restituito dalla funzione (ma su questo non sono sicuro al 100%).
Nota: a me il BCC 5.5 non da nessun warning....
Proverò a controllare meglio.
Ciao  Manlio Perillo


Per problemi di usura aggravati io consiglierei (vedi mie risposte a Libra):
inline int Mrand(int max) { return(max*(rand()/(1.0+RAND_MAX))); }
Ciao  Manlio Perillo

 wrote in message
news:LFou7.115424$P04.9...@news2.tin.it...

Se rileggi il thread scopri che in effetti il cast finale e' inutile in termini
di linguaggio, ma se omesso puo' dar luogo a dei warning su alcuni compilatori.
Questo genere di warning IMO dovrebbe essere eliminato dall'output di un
compilatore ed essere eventualmente parte di un Lint. Ma molti non usano Lint e
preferiscono avere dei compilatori che generano warning per codice che e' solo
"potenzialmente" sbagliato (ovvero e' giusto a meno che tu non abbia sbagliato a
scrivere!!).


 giusto a meno che tu non abbia sbagliato a scrivere!!).
cos'e' un Lint?


 cos'e' un Lint?
Nasce ai tempi dei vecchi compilatori C.
Un compilatore C "ragiona" su un file (o meglio una translation unit) per volta
(usi make per invocarlo su tutti i sorgenti). Inoltre si concentra sul
linguaggio in se e non sulla logica del programma.
Un Lint invece analizza tutti i sorgenti. Non genera codice, ma genera errori e,
soprattutto, warnings.
Per esempio e' in grado di "coglierti" situazioni di uso improprio dei parametri
(pensa al C pre ansi con i parametri non prototipati). Ma nel tempo i Lint sono
diventati molto piu' furbi e riescono ad accorgersi di problemi non banali Pensa
a codice tipo:
void foo( int *p, int i ) {
    p[i]=0;
}
int pippo() {
    return 4;
}
void bar( int *p ) {
    foo(p+2,pippo());
}
...
    int v[8];
    bar( &v[3] );
ma molto piu' complesso (magari con le costanti che sono calcolate etc.).
Naturalmente con le funzioni che stanno in TU differenti. Alcuni Lint riescono
ad accorgersi che la chiamata a bar (quella specifica chiamata) porta certamente
ad un out of bound.
Naturalmente questo e' solo un piccolo esempio.
Il concetto e' che un Lint analizza i sorgenti nel loro complesso e va alla
caccia di errori che non hanno nulla a che vedere con la definizione del
linguaggio in se (ovviamente ti segnalano anche gli errori che ti segnalerebbe
un compilatore).
Moltissimi "warning" presenti su alcuni compilaotori sono in realtą dei backfit
da Lint. Un vecchio compilatore non si sarebbe mai sognato di darti un warning
sul possibile uso improprio di = in codice tipo:
  if ( a=b )
che in C e C++ e' perfettamente legale. Storicamente questo genere di errori
veniva segnalato da Lint, non dal compilatore.
Io sostengo che i compilatori moderni dovrebbero smetterla di cercare di
segnalare "potenziali problemi" e limitarsi ad una diagnostica legata al
linguaggio (quindi nessun warning se non c'e' ragionevole sicurezza che il
risultato non e' quello voluto) e dovrebbero invece essere "accompagnati" da un
Linter (cosi' come sono spesso accompagnati da Linker, Librarian e Debugger). E
naturalmente il Linter dovrebbe essere MOLTO piu' potente, nella diagnostica,
del livello attuale dei compilatori.
