W dniu piątek, 1 grudnia 2017 07:01:53 UTC+1 użytkownik Adam Klobukowski napisał:
> W dniu środa, 29 listopada 2017 14:01:44 UTC+1 użytkownik slawek napisał:
> > On Wed, 29 Nov 2017 02:23:29 -0800 (PST), "M.M." <m...@g...com>
> > wrote:
> > > Ale czyje? Moje nastawienie? A jakie masz wyobrażenie o moim
> > > nastawieniu, poprawnie zdekodowałeś moje nastawienie?
> >
> > Domagasz się pomocy, a nawet nie zdefiniowałeś dokładnie problemu.
> > Chcesz pisać w Asemblerze, ale nie chcesz się przepracować. Chcesz
> > pomocy, ale nie piszesz o jaki CPU chodzi (tyle że to nie x86).
>
> Heh. Mnie chodzi o najprostszy generatow liczb pseudolosowych. Nie będe go nijak
testował (poza 'na oko') bo nie będzie na nim wisieć los wszechświata, kluczy
szyfrujących też nie będę nim generował. Po prostu potrzebuję czegoś co pozwoli łatwo
i w miare szybko wygenerowć ca. 1M liczb z odpowiednich zakresów.
>
> > Chcesz pisać swój własny generator. Ale nie masz narzędzi do jego
> > testowania. Chcesz szybko i byle jak, ale nie masz pojęcia jak i jak
> > zacząć. No i fajnie.
>
> Tak, chcę szybko i byle jak. Jak już napisałem wyżej - nie piszę nic krytycznego.
>
> > A książek nie będziesz czytać bo nie. Też zupełnie gites.
>
> Nic takiego nigdzie nie napisałem.
>
> AdamK

polecam pozagladac do otwartych implementacji stdlib c,

tutaj jest no jedna funkcja

https://sourceware.org/git/?p=glibc.git;a=blob_plain
;f=stdlib/rand_r.c;hb=HEAD

jakis miesiac przegladalem inna implementacje stdlib i tam ta funkcja byla nawet
krotsza (miala ze 3 linijki)

co prawda tu w zrodlach tam wyzej jest jakas bardziej 'fancy' wersja
ktora jest jak piszą 'lepsza' ale
pewnie i sporo wolniejsza

https://sourceware.org/git/?p=glibc.git;a=blob_plain
;f=stdlib/random.c;hb=HEAD

do góry

W dniu środa, 6 grudnia 2017 10:41:01 UTC+1 użytkownik fir napisał:
> W dniu piątek, 1 grudnia 2017 07:01:53 UTC+1 użytkownik Adam Klobukowski napisał:
> > W dniu środa, 29 listopada 2017 14:01:44 UTC+1 użytkownik slawek napisał:
> > > On Wed, 29 Nov 2017 02:23:29 -0800 (PST), "M.M." <m...@g...com>
> > > wrote:
> > > > Ale czyje? Moje nastawienie? A jakie masz wyobrażenie o moim
> > > > nastawieniu, poprawnie zdekodowałeś moje nastawienie?
> > >
> > > Domagasz się pomocy, a nawet nie zdefiniowałeś dokładnie problemu.
> > > Chcesz pisać w Asemblerze, ale nie chcesz się przepracować. Chcesz
> > > pomocy, ale nie piszesz o jaki CPU chodzi (tyle że to nie x86).
> >
> > Heh. Mnie chodzi o najprostszy generatow liczb pseudolosowych. Nie będe go nijak
testował (poza 'na oko') bo nie będzie na nim wisieć los wszechświata, kluczy
szyfrujących też nie będę nim generował. Po prostu potrzebuję czegoś co pozwoli łatwo
i w miare szybko wygenerowć ca. 1M liczb z odpowiednich zakresów.
> >
> > > Chcesz pisać swój własny generator. Ale nie masz narzędzi do jego
> > > testowania. Chcesz szybko i byle jak, ale nie masz pojęcia jak i jak
> > > zacząć. No i fajnie.
> >
> > Tak, chcę szybko i byle jak. Jak już napisałem wyżej - nie piszę nic krytycznego.
> >
> > > A książek nie będziesz czytać bo nie. Też zupełnie gites.
> >
> > Nic takiego nigdzie nie napisałem.
> >
> > AdamK
>
> polecam pozagladac do otwartych implementacji stdlib c,
>
> tutaj jest no jedna funkcja
>
> https://sourceware.org/git/?p=glibc.git;a=blob_plain
;f=stdlib/rand_r.c;hb=HEAD
>
> jakis miesiac przegladalem inna implementacje stdlib i tam ta funkcja byla nawet
krotsza (miala ze 3 linijki)
>
> co prawda tu w zrodlach tam wyzej jest jakas bardziej 'fancy' wersja
> ktora jest jak piszą 'lepsza' ale
> pewnie i sporo wolniejsza
>
> https://sourceware.org/git/?p=glibc.git;a=blob_plain
;f=stdlib/random.c;hb=HEAD

ps wiem ze to nie jest 8 bit z limitem ale nie znam tekaiej implementacji, trzebby
moze sobie samemu napisac a by to zrobic trzebby troche ogarnac ta teorie randów a
szczerze mowiac nie wiem czy warto w to inwestowac osobisty czas

do góry

Użytkownik "fir" <p...@g...com> napisał:

> ps wiem ze to nie jest 8 bit z limitem ale nie znam tekaiej implementacji, trzebby
moze sobie
> samemu napisac
> a by to zrobic trzebby troche ogarnac ta teorie randów a szczerze mowiac nie wiem
czy warto w to
> inwestowac osobisty czas

Alez to bardzo proste:

rand() & 0xFF // ;)

PS: ;) do innych - nie do Ciebie betonie programistyczny

AK

do góry

On Wed, 06 Dec 2017 09:58:36 +0100, slawek wrote:

>> Ostatnio? 'Viriona' Ziemańskiego.
>
> A co w niej piszą o generatorach liczb pseudolosowych?

Nie czytałeś?

--
pozdrawiam
Roman Tyczka

do góry

On Wed, 6 Dec 2017 20:07:24 +0100, "AK" <n...@n...net> wrote:
> rand() & 0xFF // ;)
> PS: ;) do innych - nie do Ciebie betonie
> AK

Ajtam, Fir jest jeszcze ok.

Dzisiaj miałem wątpliwą przyjemność z naćpaną? panienką od tomografu
co to nie potrafiła spuścić danych na DVD. I że trzy płyty zepsuła.

A dlaczego naćpaną? Cały czas nakręcona krzyczała odpowiedzi na
niezadane pytania. Atmosfera jak z horroru: idziesz do lekarza a
lekarz psychopata.

Przy okazji dowiedziałem się, że nie potrafią nałożyć na siebie
obrazów CT i NMR. Dlaczego? Bo "nikt nie potrafi napisać programu".
I jeszcze "my rezonans trzy dni obrabiamy". Kurcze blade, na Tesli
to już chyba real time, a chwalili się że mają nówka aparat.

Anyway, to była prywatna "klinika".

do góry

On Wed, 6 Dec 2017 20:07:24 +0100, "AK" <n...@n...net> wrote:
> rand() & 0xFF // ;)

Lepiej (rand() >> 4) & 0xff

Najniższe bity wywalić.

do góry

Użytkownik "slawek" <f...@f...com> napisał:
>> rand() & 0xFF // ;)
>
> Lepiej (rand() >> 4) & 0xff
>
> Najniższe bity wywalić.

To prawda, ale oni chcieli "szybciej", a nie "lepiej" :)
PS: Oczywiscie generalnie to byl zart (no nie tak znow w 100%:)

AK

do góry

On Thursday, December 7, 2017 at 1:10:25 AM UTC+1, AK wrote:
> Użytkownik "slawek" <f...@f...com> napisał:
> >> rand() & 0xFF // ;)
> >
> > Lepiej (rand() >> 4) & 0xff
> >
> > Najniższe bity wywalić.
>
> To prawda, ale oni chcieli "szybciej", a nie "lepiej" :)
> PS: Oczywiscie generalnie to byl zart (no nie tak znow w 100%:)

W Wieczorkowskim jest podanych kilka parametrów dla generatorów
Fibonacciego. Sprawdzałem, działają bardzo szybko i przechodzą dużo
testów. Zazwyczaj są znacznie lepsze niż generator liniowy, a
nawet MT. Jeśli to nie był żart, to napiszcie, czemu nie użyć
Fibonacciego?

Pozdrawiam

Pozdrawiam

do góry

On Thursday, December 7, 2017 at 1:10:25 AM UTC+1, AK wrote:
> Użytkownik "slawek" <f...@f...com> napisał:
> >> rand() & 0xFF // ;)
> >
> > Lepiej (rand() >> 4) & 0xff
> >
> > Najniższe bity wywalić.
>
> To prawda, ale oni chcieli "szybciej", a nie "lepiej" :)
> PS: Oczywiscie generalnie to byl zart (no nie tak znow w 100%:)
>
> AK


Zwykły liniowy też może nieźle przechodzić diehardera, ale ma
operację modulo na uint64, więc nie działa super szybko:

#include <cstdio>
#include <cstdlib>

#define N (1000)

unsigned int frand() {
static unsigned long long x = 3456;
return x = ( 67867967ull * x + 373587883ull ) % 22801763489ull;
}

int main(int argc, char *argv[]) {
while( true ) {
unsigned char x[N];
for( int i=0 ; i<N ; i++ ) {
x[i] = (unsigned char)( ( frand() >> 12 ) & 0xff );
}
fwrite( x , 1 , N , stdout );
}
return 0;
}


time ./frnd | dieharder -a -m 1 -g 200
#===================================================
==========================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#===================================================
==========================#
rng_name |rands/second| Seed |
stdin_input_raw| 2.08e+07 |2780121314|
#===================================================
==========================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#===================================================
==========================#
diehard_birthdays| 0| 100| 100|0.46063422| PASSED
diehard_operm5| 0| 1000000| 100|0.31333531| PASSED
diehard_rank_32x32| 0| 40000| 100|0.93698626| PASSED
diehard_rank_6x8| 0| 100000| 100|0.91729484| PASSED
diehard_bitstream| 0| 2097152| 100|0.88623878| PASSED
diehard_opso| 0| 2097152| 100|0.04569037| PASSED
diehard_oqso| 0| 2097152| 100|0.67464303| PASSED
diehard_dna| 0| 2097152| 100|0.11851483| PASSED
diehard_count_1s_str| 0| 256000| 100|0.99351326| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.27087944| PASSED
diehard_parking_lot| 0| 12000| 100|0.48712953| PASSED
diehard_2dsphere| 2| 8000| 100|0.71869890| PASSED
diehard_3dsphere| 3| 4000| 100|0.06056982| PASSED
diehard_squeeze| 0| 100000| 100|0.12027489| PASSED
diehard_sums| 0| 100| 100|0.03918554| PASSED
diehard_runs| 0| 100000| 100|0.79798093| PASSED
diehard_runs| 0| 100000| 100|0.70611138| PASSED
diehard_craps| 0| 200000| 100|0.72556415| PASSED
diehard_craps| 0| 200000| 100|0.91109206| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.10109988| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.39278261| PASSED
sts_monobit| 1| 100000| 100|0.99866272| WEAK
sts_runs| 2| 100000| 100|0.52353357| PASSED
sts_serial| 1| 100000| 100|0.49463645| PASSED
sts_serial| 2| 100000| 100|0.23074460| PASSED
sts_serial| 3| 100000| 100|0.53546328| PASSED
sts_serial| 3| 100000| 100|0.86112117| PASSED
sts_serial| 4| 100000| 100|0.85038482| PASSED
sts_serial| 4| 100000| 100|0.67397315| PASSED
sts_serial| 5| 100000| 100|0.60585098| PASSED
sts_serial| 5| 100000| 100|0.54968851| PASSED
sts_serial| 6| 100000| 100|0.99277070| PASSED
sts_serial| 6| 100000| 100|0.68076764| PASSED
sts_serial| 7| 100000| 100|0.60350923| PASSED
sts_serial| 7| 100000| 100|0.16223947| PASSED
sts_serial| 8| 100000| 100|0.44079302| PASSED
sts_serial| 8| 100000| 100|0.27416319| PASSED
sts_serial| 9| 100000| 100|0.58490231| PASSED
sts_serial| 9| 100000| 100|0.49073425| PASSED
sts_serial| 10| 100000| 100|0.98547876| PASSED
sts_serial| 10| 100000| 100|0.61975871| PASSED
sts_serial| 11| 100000| 100|0.83174032| PASSED
sts_serial| 11| 100000| 100|0.74740837| PASSED
sts_serial| 12| 100000| 100|0.04825508| PASSED
sts_serial| 12| 100000| 100|0.34237994| PASSED
sts_serial| 13| 100000| 100|0.25836505| PASSED
sts_serial| 13| 100000| 100|0.54657267| PASSED
sts_serial| 14| 100000| 100|0.53319336| PASSED
sts_serial| 14| 100000| 100|0.66858312| PASSED
sts_serial| 15| 100000| 100|0.17449009| PASSED
sts_serial| 15| 100000| 100|0.36364894| PASSED
sts_serial| 16| 100000| 100|0.74664519| PASSED
sts_serial| 16| 100000| 100|0.61780527| PASSED
rgb_bitdist| 1| 100000| 100|0.62404389| PASSED
rgb_bitdist| 2| 100000| 100|0.76697955| PASSED
rgb_bitdist| 3| 100000| 100|0.33500938| PASSED
^C

real 8m36.320s
user 11m9.300s
sys 0m13.596s

do góry

On Thursday, December 7, 2017 at 1:10:25 AM UTC+1, AK wrote:
> Użytkownik "slawek" <f...@f...com> napisał:
> >> rand() & 0xFF // ;)
> >
> > Lepiej (rand() >> 4) & 0xff
> >
> > Najniższe bity wywalić.
>
> To prawda, ale oni chcieli "szybciej", a nie "lepiej" :)
> PS: Oczywiscie generalnie to byl zart (no nie tak znow w 100%:)
>
> AK

Generator Fibonacciego też można napisać w 10 minut na
kolanie i, jak na razie, przeszedł kilkanaście początkowych
diehardera nawet na m=30. Generowanie liczb jest ekstremalnie
szybkie, nie zawiera nawet ifa. Niestety nie wiadomo czy dla
innych zarodków też zachowa się tak samo dobrze :/ I drugie
niestety: poniższa implementacja wymaga ponad 16k bajtów ram.

Kod:
class FibRnd {
private:
unsigned int a,b,c;
unsigned int *x;
unsigned int max;

public:
FibRnd(unsigned int seed) {
max = 1<<12;
a = 0;
b = 16;
c = max-1;
x = new unsigned int[max];
for( unsigned int i=0 ; i<max * 4 ; i++ ) {
x[i%max] <<= 4;
x[i%max] ^= seed = ((seed * 359ull + 3733ull) % 1057767ull);
}
}
~FibRnd() {
delete[] x;
}
unsigned int operator ()() {
a = (a+1)&(max-1);
b = (b+1)&(max-1);
c = (c+1)&(max-1);
return x[c] = x[a] + x[b];
}

};

int main( int argc, char *argv[] ) {
FibRnd rnd((unsigned int)time(NULL));
while( true ) {
unsigned char x[N];
for( int i=0 ; i<N ; i++ )
x[i] = (unsigned char)rnd();
fwrite( x , 1 , N , stdout );
}
return 0;
}

Test:
time ./frnd | dieharder -a -m 30 -g 200
#===================================================
==========================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#===================================================
==========================#
rng_name |rands/second| Seed |
stdin_input_raw| 3.00e+07 |2482448351|
#===================================================
==========================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#===================================================
==========================#
diehard_birthdays| 0| 100| 3000|0.29234458| PASSED
diehard_operm5| 0| 1000000| 3000|0.51398474| PASSED
diehard_rank_32x32| 0| 40000| 3000|0.36767415| PASSED
diehard_rank_6x8| 0| 100000| 3000|0.69227346| PASSED
diehard_bitstream| 0| 2097152| 3000|0.30960016| PASSED
diehard_opso| 0| 2097152| 3000|0.85888419| PASSED
diehard_oqso| 0| 2097152| 3000|0.67207083| PASSED
diehard_dna| 0| 2097152| 3000|0.00012554| WEAK
diehard_count_1s_str| 0| 256000| 3000|0.51597335| PASSED
diehard_count_1s_byt| 0| 256000| 3000|0.26197695| PASSED
diehard_parking_lot| 0| 12000| 3000|0.17469806| PASSED
diehard_2dsphere| 2| 8000| 3000|0.54418532| PASSED
diehard_3dsphere| 3| 4000| 3000|0.87789531| PASSED
diehard_squeeze| 0| 100000| 3000|0.26815462| PASSED
diehard_sums| 0| 100| 3000|0.00000000| FAILED
diehard_runs| 0| 100000| 3000|0.01445376| PASSED
diehard_runs| 0| 100000| 3000|0.00537657| PASSED
diehard_craps| 0| 200000| 3000|0.93729302| PASSED
diehard_craps| 0| 200000| 3000|0.34274658| PASSED



Pozdrawiam

P.S.
Nie patrzcie na diehard_sums, bo ten test zawiera błędy.

do góry