Newsgroup: it.hobby.enigmi
Titolo: per livio: darwin machine

ho trovato sul tuo sito questo procedimento 
insolito..
molto ingegnoso
ho provato a implementarlo in c, e' tutto molto
semplice come dici tu tranne non riesco a far
'funzionare' la funzione caso:
Caso = 1 + (-1)^Int(RND*2) * RND^n con n>=2
Int per cosa sta?
non conosco il basic e non riesco a capire se e' 
una funzione del basic oppure no
perche' per esempio plottando:
eq := 1 * (1 + (-1)^(y * 2) * y^5);
      ^
dove x=1, non viene fuori un bel niente e nemmeno 
per altri x
e' dovuto tutto a quell'Int mancante ?
sono molto interessato all'argomento, se hai tempo 
di spiegarmi mi fai un favore
ciao!
(ti contatto qua perche' il tuo indirizzo mi da 
failure delivery su yahu')


.
.RND in basic e' un numero
casuale da 0 a 0.9999...
.Int() e' la funzione 'Intero'
.(-1)^Int(RND*2)
diventa un segno casuale col 50% di probabilita' per il piu' e 50% per il
meno.
.
.'Caso' diventa un numero circa uguale a uno con una variazione
attorno al valore uno che approssima una gausiana tanto piu' a spillo
quanto n e' elevato. Anche altre funzioni spesso vanno bene: ad es.
Caso=0.9+RND/5 vale 1+-0.1
.
.
l...@tin.it
 e' un indirizzo falso perche' mi
sono stufato delle tonnellate di spam che arrivano dai NG. Per trovare
quello vero bisogna usare quello del mio sito.
.
.Spero di essere stato
chiaro, diversamente ridomanda perche' ci tengo alla mia Darwin Machine e
alla sua diffusione. Che Darwin sia con te!
.
Ciao!
Livio
--------------------------------
Inviato via 
http://usenet.iol.it
 

grazie mi e' stato molto utile questo chiarimento
in c infatti rnd ritorna valori da 0 a MAXINT 
quindi tutt'altro che 0 - 0.9999
:)
mi sa che in c posso mettere cos(rand()*Pigreco)
almeno mi tolgo il problema del rand() troppo 
generoso e ottengo sempre un segno alternato a caso
ancora complimenti per l'idea, l'approvo in pieno

non riesco a farla convergere :\
m'e' riuscito una mezza volta, ma non tanto bene
y = (0 .. MAXINT) (e' un intero insomma)
mettendo teta = (-1)^(y) + (1/(y+1))
x = x+(-1+teta)
ottengo dei valori oscillanti ma non converge manco 
per niente
se spingo di piu' sulla sensibilita' ( ad esempio 
1/(y*y)) il risultato e' sempre +1 o -1 su teta 
quindi non cambia mai nulla
li' e' un problema del linguaggio
se trattasse numeri piu' precisi!




.
.
.
Non sto comprendendo al 100% quello che stai
facendo.
Il problema di solito e' ottenere un coefficiente moltiplicativo
per la (o le) variabile in gioco pari a 1+-tot con tot piccolo e casuale,
purche' le variabili stiano lontano dallo zero, se no bisogna aggiungere
una componente casuale additiva.
Il linguaggio C dovrebbe consentirti di
definire le variabili con la precisione desiderata, e' una sua prerogativa.
Se vuoi scrivimi qua: 
livio...@tiscalinet.it
pero' ti potro' rispondere
solo lunedi'.
Stai cercando di risolvere un problema qualunque per
esercizio o hai uno specifico problema da risolvere? In quest'ultimo caso
potrei darti una mano coi miei mezzi.
.
Buona notte  :o)



Scusa l'intromissione, ma io non scomoderei la trigonometria quando tutto
può rimanere nell'ambito degli interi.
In C, per ottenere un valore a caso che sia -1 o 1 puoi usare: rand() % 2 *
2 - 1 o anche (rand() % 2 << 1) - 1.
Lo spiego per chi fosse interessato e non conoscesse il linguaggio C: rand()
ritorna un intero compreso tra 0 e 32767; % è l'operatore modulo, % 2
restituisce o 0 o 1; << 1 fa lo shift a sinistra di un bit (cioè moltiplica
per 2) e quindi siamo a 0 o 2; -1 riporta tutto tra -1 o 1.
Ciao :-)
Giorgio

infatti, non c'e' proprio bisogno
basta un (-1)^rand()
.. ho altri problemi cmq :)


Sě, anche se sono sempre dell'idea che, per motivi di efficienza ed
eleganza, sia da evitare di scomodare i reali quando si puň rimanere
nell'ambito degli interi. L'elevamento a potenza (che in C si ottiene
ricorrendo alla funzione pow() ) č definito nell'ambito dei double.
L'operatore ^ fa l'or esclusivo bit a bit.
Capisco comunque che sia una questione di gusti e che i veri problemi siano
altri, quindi usa pure quello che ti piace di piů! :-)))
... perň te ne propongo un altro: ((rand() & 1) << 1) - 1   :-)))  ( & 1
maschera il bit a destra)
Ciao :-)
Giorgio


Questo dovrebbe essere il piů compatto (ma non si puň mai dire :-) ):
(rand() & 2) - 1
In VB farei cosě: (Rnd < .5) * 2 + 1 (tanto per rendere "criptico" anche il
VB!) :-)))
Basta. Prometto che non vi tormento piů! :-) Ribadisco comunque che ogni
soluzione č lecita (purché funzioni) soprattutto quando il problema vero sta
da un'altra parte!
Ciao :-)
Giorgio

 
   Pero` e` consigliabile ricorrere ai bit piu` significativi. Quelli meno
significativi sono solitamente poco affidabili. Qualcosa come
(rand() > (MAXINT >> 1) ? -1 : 1) :-)