On Monday, August 23, 2021 at 2:31:39 PM UTC+2, o...@g...com wrote:
> poniedziałek, 23 sierpnia 2021 o 11:18:03 UTC+2 M.M. napisał(a):
> > On Monday, August 23, 2021 at 5:23:14 AM UTC+2, o...@g...com wrote:
> > > Właściwie to mój generator oblewa po 16 MB:
> > >
> > > length= 16 megabytes (2^24 bytes), time= 2.1 seconds
> > >
> > > A ten LCG oblewa po 2 MB:
> > >
> > > length= 2 megabytes (2^21 bytes), time= 3.3 seconds
> > >
> > > Czyli mój radzi sobie chyba lepiej. O ile to ma w ogóle jakiekolwiek znaczenie,
skoro testy prawdopodobnie nie są wykonywane poprawnie. Raczej wróżenie z fusów.
> > Jeśli użyłeś tego samego generatora co ja, tych samych stałych A i B, jeśli
zainicjowałeś x=1, jeśli odrzuciłeś sto
> > początkowych wygenerowanych liczb (500 bitów), jeśli bierzesz tylko 5
najstarszych bitów - to powinno być tak samo jak
> > u mnie... chociaż ja mam wersję PractRanda 0.94 a Ty 0.93 - nie wiem czy zostało
zmienione coś na tyle
> > istotnego aby wyniki testów były całkiem inne. Raczej w nowszej wersji testy
powinny być bardziej surowe.
> >
> > Moje początkowe 1000 bitów wygląda tak:
> > ./SimpPRNG 1 1000
> > 1100010111000111110000011110101111001001011010001110
0011110011110000000011111001000101101111111000001111
1110100100110000011011001100101110100010010011011101
1111001010111011011101001101100110001001111000101011
0000010000011101011010011111101111110000010110010111
1110001010100101000000010111111000011001001110011110
1011010111110000100101100110100001110100000110101010
0011000100000110001111011100011100111110001011011101
0011001011001101100000100110110001101101111110010100
0010110101110111011010111111100001101101011101011011
1000001000011100100111000100011011000111100110001000
1001101100110001010001001111001110100101001000001101
0101000101111100100101110010011000001000001101101100
1101011100001010110100111101011010001000101100000001
0100111111010111001100111000111011001111001110101110
1000001001001001100100111110111110110000110010101011
0110011000101000101110000100101001001000000111010101
0100110100101110101111000100011100000000011000000010
1110000010110100110111011000100010101110000010010011
001101000101
> >
> > Wyświetlam z tych 5 bitów począwszy od najmłodszego:
> >
> > https://github.com/mmarszik/SimpPRNG/blob/main/main.
cpp
> > type_out v = r();
> > for( int k=0 ; k<bits && j<BUFF_SIZE && i<size ; k++, j++, i++ ) {
> > buff[j] = '0' + (v & 1);
> > v >>= 1;
> > }
> >
> > Ale na jakość generatora i zaliczenie testów nie powinno wpłynąć wyświetlanie od
najstarszego.
> >
> > Początkowe liczby z tego generatora są statystycznie bardzo słabe jeśli inicjuje
się małą liczbą
> > (np. jedynką), jest dużo zer na początku, warto odrzucić np. 100 początkowych
generowań.
> >
> > Pozdrawiam
> Mam inne wyniki. Oto wyniki w formacie dziesiętnym:
>
> x = 1
>
> x = (x * 79908886691 + 8143076871913) & 340282366920938463463374607431768211455 =
8222985758604
>
> 8222985758604 >> 123 = 0
>
> x = (8222985758604 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 657089637254136791211277
>
> 657089637254136791211277 >> 123 = 0
>
> x = (657089637254136791211277 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 52507301369171109219924401511286320
>
> 52507301369171109219924401511286320 >> 123 = 0
>
> x = (52507301369171109219924401511286320 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 333442790507095493699328894974793383801
>
> 333442790507095493699328894974793383801 >> 123 = 31
>
> x = (333442790507095493699328894974793383801 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 225174366013576153541971350915313012980
>
> 225174366013576153541971350915313012980 >> 123 = 21
>
> Czyli uzyskuję:
>
> 0
> 0
> 0
> 31
> 21
>
> I tak dalej. Jak mogą tu wychodzić inne wyniki?

Jeśli nie ma błędów, to w tym przypadku nie można uzyskać innych wyników. Jeśli nie
pomijam 100 początkowych
wygenerowanych liczb, to mam takie same liczby jak Ty:

0
0
0
31
21
4
3
9
9
7
25
12
15
16
24
11
20
14
25
27

Jeśli pomijam to mam takie:

3
29
24
7
24
11
15
18
22
24
17
7
15
0
28
19
8
27
31
0

W wielu generatorach początkowe liczby uznawane są za kiepskie. Jeśli to jest ważne,
pomija
się wiele początkowych liczb. Ten generator jest tylko do minimalnego sprawdzenia,
ale jakoś
odruchowo pominąłem chociaż 100 początkowych liczb. Generalnie, pobieranie co N-tego
bitu to
najprostsza technika zwiększająca jakość generatora - ale spowalniająca generator.

do góry

poniedziałek, 23 sierpnia 2021 o 15:05:27 UTC+2 M.M. napisał(a):
> On Monday, August 23, 2021 at 2:31:39 PM UTC+2, o...@g...com wrote:
> > poniedziałek, 23 sierpnia 2021 o 11:18:03 UTC+2 M.M. napisał(a):
> > > On Monday, August 23, 2021 at 5:23:14 AM UTC+2, o...@g...com wrote:
> > > > Właściwie to mój generator oblewa po 16 MB:
> > > >
> > > > length= 16 megabytes (2^24 bytes), time= 2.1 seconds
> > > >
> > > > A ten LCG oblewa po 2 MB:
> > > >
> > > > length= 2 megabytes (2^21 bytes), time= 3.3 seconds
> > > >
> > > > Czyli mój radzi sobie chyba lepiej. O ile to ma w ogóle jakiekolwiek
znaczenie, skoro testy prawdopodobnie nie są wykonywane poprawnie. Raczej wróżenie z
fusów.
> > > Jeśli użyłeś tego samego generatora co ja, tych samych stałych A i B, jeśli
zainicjowałeś x=1, jeśli odrzuciłeś sto
> > > początkowych wygenerowanych liczb (500 bitów), jeśli bierzesz tylko 5
najstarszych bitów - to powinno być tak samo jak
> > > u mnie... chociaż ja mam wersję PractRanda 0.94 a Ty 0.93 - nie wiem czy
zostało zmienione coś na tyle
> > > istotnego aby wyniki testów były całkiem inne. Raczej w nowszej wersji testy
powinny być bardziej surowe.
> > >
> > > Moje początkowe 1000 bitów wygląda tak:
> > > ./SimpPRNG 1 1000
> > > 1100010111000111110000011110101111001001011010001110
0011110011110000000011111001000101101111111000001111
1110100100110000011011001100101110100010010011011101
1111001010111011011101001101100110001001111000101011
0000010000011101011010011111101111110000010110010111
1110001010100101000000010111111000011001001110011110
1011010111110000100101100110100001110100000110101010
0011000100000110001111011100011100111110001011011101
0011001011001101100000100110110001101101111110010100
0010110101110111011010111111100001101101011101011011
1000001000011100100111000100011011000111100110001000
1001101100110001010001001111001110100101001000001101
0101000101111100100101110010011000001000001101101100
1101011100001010110100111101011010001000101100000001
0100111111010111001100111000111011001111001110101110
1000001001001001100100111110111110110000110010101011
0110011000101000101110000100101001001000000111010101
0100110100101110101111000100011100000000011000000010
1110000010110100110111011000100010101110000010010011
001101000101
> > >
> > > Wyświetlam z tych 5 bitów począwszy od najmłodszego:
> > >
> > > https://github.com/mmarszik/SimpPRNG/blob/main/main.
cpp
> > > type_out v = r();
> > > for( int k=0 ; k<bits && j<BUFF_SIZE && i<size ; k++, j++, i++ ) {
> > > buff[j] = '0' + (v & 1);
> > > v >>= 1;
> > > }
> > >
> > > Ale na jakość generatora i zaliczenie testów nie powinno wpłynąć wyświetlanie
od najstarszego.
> > >
> > > Początkowe liczby z tego generatora są statystycznie bardzo słabe jeśli
inicjuje się małą liczbą
> > > (np. jedynką), jest dużo zer na początku, warto odrzucić np. 100 początkowych
generowań.
> > >
> > > Pozdrawiam
> > Mam inne wyniki. Oto wyniki w formacie dziesiętnym:
> >
> > x = 1
> >
> > x = (x * 79908886691 + 8143076871913) & 340282366920938463463374607431768211455 =
8222985758604
> >
> > 8222985758604 >> 123 = 0
> >
> > x = (8222985758604 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 657089637254136791211277
> >
> > 657089637254136791211277 >> 123 = 0
> >
> > x = (657089637254136791211277 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 52507301369171109219924401511286320
> >
> > 52507301369171109219924401511286320 >> 123 = 0
> >
> > x = (52507301369171109219924401511286320 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 333442790507095493699328894974793383801
> >
> > 333442790507095493699328894974793383801 >> 123 = 31
> >
> > x = (333442790507095493699328894974793383801 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 225174366013576153541971350915313012980
> >
> > 225174366013576153541971350915313012980 >> 123 = 21
> >
> > Czyli uzyskuję:
> >
> > 0
> > 0
> > 0
> > 31
> > 21
> >
> > I tak dalej. Jak mogą tu wychodzić inne wyniki?
> Jeśli nie ma błędów, to w tym przypadku nie można uzyskać innych wyników. Jeśli nie
pomijam 100 początkowych
> wygenerowanych liczb, to mam takie same liczby jak Ty:
> 0
> 0
> 0
> 31
> 21
> 4
> 3
> 9
> 9
> 7
> 25
> 12
> 15
> 16
> 24
> 11
> 20
> 14
> 25
> 27
>
> Jeśli pomijam to mam takie:
>
> 3
> 29
> 24
> 7
> 24
> 11
> 15
> 18
> 22
> 24
> 17
> 7
> 15
> 0
> 28
> 19
> 8
> 27
> 31
> 0
>
> W wielu generatorach początkowe liczby uznawane są za kiepskie. Jeśli to jest
ważne, pomija
> się wiele początkowych liczb. Ten generator jest tylko do minimalnego sprawdzenia,
ale jakoś
> odruchowo pominąłem chociaż 100 początkowych liczb. Generalnie, pobieranie co
N-tego bitu to
> najprostsza technika zwiększająca jakość generatora - ale spowalniająca generator.

Wychodzi nam to samo, myślałem, że pominąłem pierwsze 500 bitów, a pominąłeś 100.
Oczywiście zdaję sobie sprawę z tych słabości początkowych bitów, sam projektowałem
moje generatory, żeby unikać podobnych problemów. Niemniej mam przekonanie, że nawet
bez pominięcia pierwszych bitów ten generator też dobrze by sobie poradził.

Ale mniejsza z tym. Mamy te same generatory i ewidentnie problem jest z formatem
danych.

do góry

On Monday, August 23, 2021 at 3:21:47 PM UTC+2, o...@g...com wrote:
> poniedziałek, 23 sierpnia 2021 o 15:05:27 UTC+2 M.M. napisał(a):
> > On Monday, August 23, 2021 at 2:31:39 PM UTC+2, o...@g...com wrote:
> > > poniedziałek, 23 sierpnia 2021 o 11:18:03 UTC+2 M.M. napisał(a):
> > > > On Monday, August 23, 2021 at 5:23:14 AM UTC+2, o...@g...com wrote:
> > > > > Właściwie to mój generator oblewa po 16 MB:
> > > > >
> > > > > length= 16 megabytes (2^24 bytes), time= 2.1 seconds
> > > > >
> > > > > A ten LCG oblewa po 2 MB:
> > > > >
> > > > > length= 2 megabytes (2^21 bytes), time= 3.3 seconds
> > > > >
> > > > > Czyli mój radzi sobie chyba lepiej. O ile to ma w ogóle jakiekolwiek
znaczenie, skoro testy prawdopodobnie nie są wykonywane poprawnie. Raczej wróżenie z
fusów.
> > > > Jeśli użyłeś tego samego generatora co ja, tych samych stałych A i B, jeśli
zainicjowałeś x=1, jeśli odrzuciłeś sto
> > > > początkowych wygenerowanych liczb (500 bitów), jeśli bierzesz tylko 5
najstarszych bitów - to powinno być tak samo jak
> > > > u mnie... chociaż ja mam wersję PractRanda 0.94 a Ty 0.93 - nie wiem czy
zostało zmienione coś na tyle
> > > > istotnego aby wyniki testów były całkiem inne. Raczej w nowszej wersji testy
powinny być bardziej surowe.
> > > >
> > > > Moje początkowe 1000 bitów wygląda tak:
> > > > ./SimpPRNG 1 1000
> > > > 1100010111000111110000011110101111001001011010001110
0011110011110000000011111001000101101111111000001111
1110100100110000011011001100101110100010010011011101
1111001010111011011101001101100110001001111000101011
0000010000011101011010011111101111110000010110010111
1110001010100101000000010111111000011001001110011110
1011010111110000100101100110100001110100000110101010
0011000100000110001111011100011100111110001011011101
0011001011001101100000100110110001101101111110010100
0010110101110111011010111111100001101101011101011011
1000001000011100100111000100011011000111100110001000
1001101100110001010001001111001110100101001000001101
0101000101111100100101110010011000001000001101101100
1101011100001010110100111101011010001000101100000001
0100111111010111001100111000111011001111001110101110
1000001001001001100100111110111110110000110010101011
0110011000101000101110000100101001001000000111010101
0100110100101110101111000100011100000000011000000010
1110000010110100110111011000100010101110000010010011
001101000101
> > > >
> > > > Wyświetlam z tych 5 bitów począwszy od najmłodszego:
> > > >
> > > > https://github.com/mmarszik/SimpPRNG/blob/main/main.
cpp
> > > > type_out v = r();
> > > > for( int k=0 ; k<bits && j<BUFF_SIZE && i<size ; k++, j++, i++ ) {
> > > > buff[j] = '0' + (v & 1);
> > > > v >>= 1;
> > > > }
> > > >
> > > > Ale na jakość generatora i zaliczenie testów nie powinno wpłynąć wyświetlanie
od najstarszego.
> > > >
> > > > Początkowe liczby z tego generatora są statystycznie bardzo słabe jeśli
inicjuje się małą liczbą
> > > > (np. jedynką), jest dużo zer na początku, warto odrzucić np. 100 początkowych
generowań.
> > > >
> > > > Pozdrawiam
> > > Mam inne wyniki. Oto wyniki w formacie dziesiętnym:
> > >
> > > x = 1
> > >
> > > x = (x * 79908886691 + 8143076871913) & 340282366920938463463374607431768211455
= 8222985758604
> > >
> > > 8222985758604 >> 123 = 0
> > >
> > > x = (8222985758604 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 657089637254136791211277
> > >
> > > 657089637254136791211277 >> 123 = 0
> > >
> > > x = (657089637254136791211277 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 52507301369171109219924401511286320
> > >
> > > 52507301369171109219924401511286320 >> 123 = 0
> > >
> > > x = (52507301369171109219924401511286320 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 333442790507095493699328894974793383801
> > >
> > > 333442790507095493699328894974793383801 >> 123 = 31
> > >
> > > x = (333442790507095493699328894974793383801 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 225174366013576153541971350915313012980
> > >
> > > 225174366013576153541971350915313012980 >> 123 = 21
> > >
> > > Czyli uzyskuję:
> > >
> > > 0
> > > 0
> > > 0
> > > 31
> > > 21
> > >
> > > I tak dalej. Jak mogą tu wychodzić inne wyniki?
> > Jeśli nie ma błędów, to w tym przypadku nie można uzyskać innych wyników. Jeśli
nie pomijam 100 początkowych
> > wygenerowanych liczb, to mam takie same liczby jak Ty:
> > 0
> > 0
> > 0
> > 31
> > 21
> > 4
> > 3
> > 9
> > 9
> > 7
> > 25
> > 12
> > 15
> > 16
> > 24
> > 11
> > 20
> > 14
> > 25
> > 27
> >
> > Jeśli pomijam to mam takie:
> >
> > 3
> > 29
> > 24
> > 7
> > 24
> > 11
> > 15
> > 18
> > 22
> > 24
> > 17
> > 7
> > 15
> > 0
> > 28
> > 19
> > 8
> > 27
> > 31
> > 0
> >
> > W wielu generatorach początkowe liczby uznawane są za kiepskie. Jeśli to jest
ważne, pomija
> > się wiele początkowych liczb. Ten generator jest tylko do minimalnego
sprawdzenia, ale jakoś
> > odruchowo pominąłem chociaż 100 początkowych liczb. Generalnie, pobieranie co
N-tego bitu to
> > najprostsza technika zwiększająca jakość generatora - ale spowalniająca
generator.
> Wychodzi nam to samo, myślałem, że pominąłem pierwsze 500 bitów, a pominąłeś 100.
Oczywiście zdaję sobie sprawę z tych słabości początkowych bitów, sam projektowałem
moje generatory, żeby unikać podobnych problemów. Niemniej mam przekonanie, że nawet
bez pominięcia pierwszych bitów ten generator też dobrze by sobie poradził.
>
> Ale mniejsza z tym. Mamy te same generatory i ewidentnie problem jest z formatem
danych.

Super, zawęziłeś obszar w którym jest problem :)

Pozdrawiam

do góry

poniedziałek, 23 sierpnia 2021 o 15:58:45 UTC+2 M.M. napisał(a):
> On Monday, August 23, 2021 at 3:21:47 PM UTC+2, o...@g...com wrote:
> > poniedziałek, 23 sierpnia 2021 o 15:05:27 UTC+2 M.M. napisał(a):
> > > On Monday, August 23, 2021 at 2:31:39 PM UTC+2, o...@g...com wrote:
> > > > poniedziałek, 23 sierpnia 2021 o 11:18:03 UTC+2 M.M. napisał(a):
> > > > > On Monday, August 23, 2021 at 5:23:14 AM UTC+2, o...@g...com wrote:
> > > > > > Właściwie to mój generator oblewa po 16 MB:
> > > > > >
> > > > > > length= 16 megabytes (2^24 bytes), time= 2.1 seconds
> > > > > >
> > > > > > A ten LCG oblewa po 2 MB:
> > > > > >
> > > > > > length= 2 megabytes (2^21 bytes), time= 3.3 seconds
> > > > > >
> > > > > > Czyli mój radzi sobie chyba lepiej. O ile to ma w ogóle jakiekolwiek
znaczenie, skoro testy prawdopodobnie nie są wykonywane poprawnie. Raczej wróżenie z
fusów.
> > > > > Jeśli użyłeś tego samego generatora co ja, tych samych stałych A i B, jeśli
zainicjowałeś x=1, jeśli odrzuciłeś sto
> > > > > początkowych wygenerowanych liczb (500 bitów), jeśli bierzesz tylko 5
najstarszych bitów - to powinno być tak samo jak
> > > > > u mnie... chociaż ja mam wersję PractRanda 0.94 a Ty 0.93 - nie wiem czy
zostało zmienione coś na tyle
> > > > > istotnego aby wyniki testów były całkiem inne. Raczej w nowszej wersji
testy powinny być bardziej surowe.
> > > > >
> > > > > Moje początkowe 1000 bitów wygląda tak:
> > > > > ./SimpPRNG 1 1000
> > > > > 1100010111000111110000011110101111001001011010001110
0011110011110000000011111001000101101111111000001111
1110100100110000011011001100101110100010010011011101
1111001010111011011101001101100110001001111000101011
0000010000011101011010011111101111110000010110010111
1110001010100101000000010111111000011001001110011110
1011010111110000100101100110100001110100000110101010
0011000100000110001111011100011100111110001011011101
0011001011001101100000100110110001101101111110010100
0010110101110111011010111111100001101101011101011011
1000001000011100100111000100011011000111100110001000
1001101100110001010001001111001110100101001000001101
0101000101111100100101110010011000001000001101101100
1101011100001010110100111101011010001000101100000001
0100111111010111001100111000111011001111001110101110
1000001001001001100100111110111110110000110010101011
0110011000101000101110000100101001001000000111010101
0100110100101110101111000100011100000000011000000010
1110000010110100110111011000100010101110000010010011
001101000101
> > > > >
> > > > > Wyświetlam z tych 5 bitów począwszy od najmłodszego:
> > > > >
> > > > > https://github.com/mmarszik/SimpPRNG/blob/main/main.
cpp
> > > > > type_out v = r();
> > > > > for( int k=0 ; k<bits && j<BUFF_SIZE && i<size ; k++, j++, i++ ) {
> > > > > buff[j] = '0' + (v & 1);
> > > > > v >>= 1;
> > > > > }
> > > > >
> > > > > Ale na jakość generatora i zaliczenie testów nie powinno wpłynąć
wyświetlanie od najstarszego.
> > > > >
> > > > > Początkowe liczby z tego generatora są statystycznie bardzo słabe jeśli
inicjuje się małą liczbą
> > > > > (np. jedynką), jest dużo zer na początku, warto odrzucić np. 100
początkowych generowań.
> > > > >
> > > > > Pozdrawiam
> > > > Mam inne wyniki. Oto wyniki w formacie dziesiętnym:
> > > >
> > > > x = 1
> > > >
> > > > x = (x * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 8222985758604
> > > >
> > > > 8222985758604 >> 123 = 0
> > > >
> > > > x = (8222985758604 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 657089637254136791211277
> > > >
> > > > 657089637254136791211277 >> 123 = 0
> > > >
> > > > x = (657089637254136791211277 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 52507301369171109219924401511286320
> > > >
> > > > 52507301369171109219924401511286320 >> 123 = 0
> > > >
> > > > x = (52507301369171109219924401511286320 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 333442790507095493699328894974793383801
> > > >
> > > > 333442790507095493699328894974793383801 >> 123 = 31
> > > >
> > > > x = (333442790507095493699328894974793383801 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 225174366013576153541971350915313012980
> > > >
> > > > 225174366013576153541971350915313012980 >> 123 = 21
> > > >
> > > > Czyli uzyskuję:
> > > >
> > > > 0
> > > > 0
> > > > 0
> > > > 31
> > > > 21
> > > >
> > > > I tak dalej. Jak mogą tu wychodzić inne wyniki?
> > > Jeśli nie ma błędów, to w tym przypadku nie można uzyskać innych wyników. Jeśli
nie pomijam 100 początkowych
> > > wygenerowanych liczb, to mam takie same liczby jak Ty:
> > > 0
> > > 0
> > > 0
> > > 31
> > > 21
> > > 4
> > > 3
> > > 9
> > > 9
> > > 7
> > > 25
> > > 12
> > > 15
> > > 16
> > > 24
> > > 11
> > > 20
> > > 14
> > > 25
> > > 27
> > >
> > > Jeśli pomijam to mam takie:
> > >
> > > 3
> > > 29
> > > 24
> > > 7
> > > 24
> > > 11
> > > 15
> > > 18
> > > 22
> > > 24
> > > 17
> > > 7
> > > 15
> > > 0
> > > 28
> > > 19
> > > 8
> > > 27
> > > 31
> > > 0
> > >
> > > W wielu generatorach początkowe liczby uznawane są za kiepskie. Jeśli to jest
ważne, pomija
> > > się wiele początkowych liczb. Ten generator jest tylko do minimalnego
sprawdzenia, ale jakoś
> > > odruchowo pominąłem chociaż 100 początkowych liczb. Generalnie, pobieranie co
N-tego bitu to
> > > najprostsza technika zwiększająca jakość generatora - ale spowalniająca
generator.
> > Wychodzi nam to samo, myślałem, że pominąłem pierwsze 500 bitów, a pominąłeś 100.
Oczywiście zdaję sobie sprawę z tych słabości początkowych bitów, sam projektowałem
moje generatory, żeby unikać podobnych problemów. Niemniej mam przekonanie, że nawet
bez pominięcia pierwszych bitów ten generator też dobrze by sobie poradził.
> >
> > Ale mniejsza z tym. Mamy te same generatory i ewidentnie problem jest z formatem
danych.
> Super, zawęziłeś obszar w którym jest problem :)
>
> Pozdrawiam

Czy możesz mi powiedzieć co konkretnie robisz z uzyskaną liczbą w formacie
dziesiętnym w C++, że zamieniasz ją na format binarny (ten właściwy format, nie
stringa binarnego jak w Pythonie). Spróbuję popytać i znaleźć tego odpowiednik w
Pythonie.

do góry

On Monday, August 23, 2021 at 9:11:14 PM UTC+2, o...@g...com wrote:
> poniedziałek, 23 sierpnia 2021 o 15:58:45 UTC+2 M.M. napisał(a):
> > On Monday, August 23, 2021 at 3:21:47 PM UTC+2, o...@g...com wrote:
> > > poniedziałek, 23 sierpnia 2021 o 15:05:27 UTC+2 M.M. napisał(a):
> > > > On Monday, August 23, 2021 at 2:31:39 PM UTC+2, o...@g...com wrote:
> > > > > poniedziałek, 23 sierpnia 2021 o 11:18:03 UTC+2 M.M. napisał(a):
> > > > > > On Monday, August 23, 2021 at 5:23:14 AM UTC+2, o...@g...com
wrote:
> > > > > > > Właściwie to mój generator oblewa po 16 MB:
> > > > > > >
> > > > > > > length= 16 megabytes (2^24 bytes), time= 2.1 seconds
> > > > > > >
> > > > > > > A ten LCG oblewa po 2 MB:
> > > > > > >
> > > > > > > length= 2 megabytes (2^21 bytes), time= 3.3 seconds
> > > > > > >
> > > > > > > Czyli mój radzi sobie chyba lepiej. O ile to ma w ogóle jakiekolwiek
znaczenie, skoro testy prawdopodobnie nie są wykonywane poprawnie. Raczej wróżenie z
fusów.
> > > > > > Jeśli użyłeś tego samego generatora co ja, tych samych stałych A i B,
jeśli zainicjowałeś x=1, jeśli odrzuciłeś sto
> > > > > > początkowych wygenerowanych liczb (500 bitów), jeśli bierzesz tylko 5
najstarszych bitów - to powinno być tak samo jak
> > > > > > u mnie... chociaż ja mam wersję PractRanda 0.94 a Ty 0.93 - nie wiem czy
zostało zmienione coś na tyle
> > > > > > istotnego aby wyniki testów były całkiem inne. Raczej w nowszej wersji
testy powinny być bardziej surowe.
> > > > > >
> > > > > > Moje początkowe 1000 bitów wygląda tak:
> > > > > > ./SimpPRNG 1 1000
> > > > > > 1100010111000111110000011110101111001001011010001110
0011110011110000000011111001000101101111111000001111
1110100100110000011011001100101110100010010011011101
1111001010111011011101001101100110001001111000101011
0000010000011101011010011111101111110000010110010111
1110001010100101000000010111111000011001001110011110
1011010111110000100101100110100001110100000110101010
0011000100000110001111011100011100111110001011011101
0011001011001101100000100110110001101101111110010100
0010110101110111011010111111100001101101011101011011
1000001000011100100111000100011011000111100110001000
1001101100110001010001001111001110100101001000001101
0101000101111100100101110010011000001000001101101100
1101011100001010110100111101011010001000101100000001
0100111111010111001100111000111011001111001110101110
1000001001001001100100111110111110110000110010101011
0110011000101000101110000100101001001000000111010101
0100110100101110101111000100011100000000011000000010
1110000010110100110111011000100010101110000010010011
001101000101
> > > > > >
> > > > > > Wyświetlam z tych 5 bitów począwszy od najmłodszego:
> > > > > >
> > > > > > https://github.com/mmarszik/SimpPRNG/blob/main/main.
cpp
> > > > > > type_out v = r();
> > > > > > for( int k=0 ; k<bits && j<BUFF_SIZE && i<size ; k++, j++, i++ ) {
> > > > > > buff[j] = '0' + (v & 1);
> > > > > > v >>= 1;
> > > > > > }
> > > > > >
> > > > > > Ale na jakość generatora i zaliczenie testów nie powinno wpłynąć
wyświetlanie od najstarszego.
> > > > > >
> > > > > > Początkowe liczby z tego generatora są statystycznie bardzo słabe jeśli
inicjuje się małą liczbą
> > > > > > (np. jedynką), jest dużo zer na początku, warto odrzucić np. 100
początkowych generowań.
> > > > > >
> > > > > > Pozdrawiam
> > > > > Mam inne wyniki. Oto wyniki w formacie dziesiętnym:
> > > > >
> > > > > x = 1
> > > > >
> > > > > x = (x * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 8222985758604
> > > > >
> > > > > 8222985758604 >> 123 = 0
> > > > >
> > > > > x = (8222985758604 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 657089637254136791211277
> > > > >
> > > > > 657089637254136791211277 >> 123 = 0
> > > > >
> > > > > x = (657089637254136791211277 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 52507301369171109219924401511286320
> > > > >
> > > > > 52507301369171109219924401511286320 >> 123 = 0
> > > > >
> > > > > x = (52507301369171109219924401511286320 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 333442790507095493699328894974793383801
> > > > >
> > > > > 333442790507095493699328894974793383801 >> 123 = 31
> > > > >
> > > > > x = (333442790507095493699328894974793383801 * 79908886691 + 8143076871913)
& 340282366920938463463374607431768211455 = 225174366013576153541971350915313012980
> > > > >
> > > > > 225174366013576153541971350915313012980 >> 123 = 21
> > > > >
> > > > > Czyli uzyskuję:
> > > > >
> > > > > 0
> > > > > 0
> > > > > 0
> > > > > 31
> > > > > 21
> > > > >
> > > > > I tak dalej. Jak mogą tu wychodzić inne wyniki?
> > > > Jeśli nie ma błędów, to w tym przypadku nie można uzyskać innych wyników.
Jeśli nie pomijam 100 początkowych
> > > > wygenerowanych liczb, to mam takie same liczby jak Ty:
> > > > 0
> > > > 0
> > > > 0
> > > > 31
> > > > 21
> > > > 4
> > > > 3
> > > > 9
> > > > 9
> > > > 7
> > > > 25
> > > > 12
> > > > 15
> > > > 16
> > > > 24
> > > > 11
> > > > 20
> > > > 14
> > > > 25
> > > > 27
> > > >
> > > > Jeśli pomijam to mam takie:
> > > >
> > > > 3
> > > > 29
> > > > 24
> > > > 7
> > > > 24
> > > > 11
> > > > 15
> > > > 18
> > > > 22
> > > > 24
> > > > 17
> > > > 7
> > > > 15
> > > > 0
> > > > 28
> > > > 19
> > > > 8
> > > > 27
> > > > 31
> > > > 0
> > > >
> > > > W wielu generatorach początkowe liczby uznawane są za kiepskie. Jeśli to jest
ważne, pomija
> > > > się wiele początkowych liczb. Ten generator jest tylko do minimalnego
sprawdzenia, ale jakoś
> > > > odruchowo pominąłem chociaż 100 początkowych liczb. Generalnie, pobieranie co
N-tego bitu to
> > > > najprostsza technika zwiększająca jakość generatora - ale spowalniająca
generator.
> > > Wychodzi nam to samo, myślałem, że pominąłem pierwsze 500 bitów, a pominąłeś
100. Oczywiście zdaję sobie sprawę z tych słabości początkowych bitów, sam
projektowałem moje generatory, żeby unikać podobnych problemów. Niemniej mam
przekonanie, że nawet bez pominięcia pierwszych bitów ten generator też dobrze by
sobie poradził.
> > >
> > > Ale mniejsza z tym. Mamy te same generatory i ewidentnie problem jest z
formatem danych.
> > Super, zawęziłeś obszar w którym jest problem :)
> >
> > Pozdrawiam
> Czy możesz mi powiedzieć co konkretnie robisz z uzyskaną liczbą w formacie
dziesiętnym w C++, że zamieniasz ją na format binarny (ten właściwy format, nie
stringa binarnego jak w Pythonie). Spróbuję popytać i znaleźć tego odpowiednik w
Pythonie.

Nie wiem jak mogę pomóc i trochę się gubię kiedy jaki dokładnie format masz na myśli
:)

Zobacz, poniżej jest format binarny, bo ma same zera i jedynki:
01010111010101001001010
Ale przecież czytasz to jako tekst, więc może to jest format tekstowy? ;-)

Może tego szukasz:

https://stackoverflow.com/questions/908331/how-to-wr
ite-binary-data-to-stdout-in-python-3

import sys
sys.stdout.buffer.write(b"some binary data")

Pozdrawiam

do góry

poniedziałek, 23 sierpnia 2021 o 22:29:45 UTC+2 M.M. napisał(a):
> On Monday, August 23, 2021 at 9:11:14 PM UTC+2, o...@g...com wrote:
> > poniedziałek, 23 sierpnia 2021 o 15:58:45 UTC+2 M.M. napisał(a):
> > > On Monday, August 23, 2021 at 3:21:47 PM UTC+2, o...@g...com wrote:
> > > > poniedziałek, 23 sierpnia 2021 o 15:05:27 UTC+2 M.M. napisał(a):
> > > > > On Monday, August 23, 2021 at 2:31:39 PM UTC+2, o...@g...com wrote:
> > > > > > poniedziałek, 23 sierpnia 2021 o 11:18:03 UTC+2 M.M. napisał(a):
> > > > > > > On Monday, August 23, 2021 at 5:23:14 AM UTC+2, o...@g...com
wrote:
> > > > > > > > Właściwie to mój generator oblewa po 16 MB:
> > > > > > > >
> > > > > > > > length= 16 megabytes (2^24 bytes), time= 2.1 seconds
> > > > > > > >
> > > > > > > > A ten LCG oblewa po 2 MB:
> > > > > > > >
> > > > > > > > length= 2 megabytes (2^21 bytes), time= 3.3 seconds
> > > > > > > >
> > > > > > > > Czyli mój radzi sobie chyba lepiej. O ile to ma w ogóle jakiekolwiek
znaczenie, skoro testy prawdopodobnie nie są wykonywane poprawnie. Raczej wróżenie z
fusów.
> > > > > > > Jeśli użyłeś tego samego generatora co ja, tych samych stałych A i B,
jeśli zainicjowałeś x=1, jeśli odrzuciłeś sto
> > > > > > > początkowych wygenerowanych liczb (500 bitów), jeśli bierzesz tylko 5
najstarszych bitów - to powinno być tak samo jak
> > > > > > > u mnie... chociaż ja mam wersję PractRanda 0.94 a Ty 0.93 - nie wiem
czy zostało zmienione coś na tyle
> > > > > > > istotnego aby wyniki testów były całkiem inne. Raczej w nowszej wersji
testy powinny być bardziej surowe.
> > > > > > >
> > > > > > > Moje początkowe 1000 bitów wygląda tak:
> > > > > > > ./SimpPRNG 1 1000
> > > > > > > 1100010111000111110000011110101111001001011010001110
0011110011110000000011111001000101101111111000001111
1110100100110000011011001100101110100010010011011101
1111001010111011011101001101100110001001111000101011
0000010000011101011010011111101111110000010110010111
1110001010100101000000010111111000011001001110011110
1011010111110000100101100110100001110100000110101010
0011000100000110001111011100011100111110001011011101
0011001011001101100000100110110001101101111110010100
0010110101110111011010111111100001101101011101011011
1000001000011100100111000100011011000111100110001000
1001101100110001010001001111001110100101001000001101
0101000101111100100101110010011000001000001101101100
1101011100001010110100111101011010001000101100000001
0100111111010111001100111000111011001111001110101110
1000001001001001100100111110111110110000110010101011
0110011000101000101110000100101001001000000111010101
0100110100101110101111000100011100000000011000000010
1110000010110100110111011000100010101110000010010011
001101000101
> > > > > > >
> > > > > > > Wyświetlam z tych 5 bitów począwszy od najmłodszego:
> > > > > > >
> > > > > > > https://github.com/mmarszik/SimpPRNG/blob/main/main.
cpp
> > > > > > > type_out v = r();
> > > > > > > for( int k=0 ; k<bits && j<BUFF_SIZE && i<size ; k++, j++, i++ ) {
> > > > > > > buff[j] = '0' + (v & 1);
> > > > > > > v >>= 1;
> > > > > > > }
> > > > > > >
> > > > > > > Ale na jakość generatora i zaliczenie testów nie powinno wpłynąć
wyświetlanie od najstarszego.
> > > > > > >
> > > > > > > Początkowe liczby z tego generatora są statystycznie bardzo słabe jeśli
inicjuje się małą liczbą
> > > > > > > (np. jedynką), jest dużo zer na początku, warto odrzucić np. 100
początkowych generowań.
> > > > > > >
> > > > > > > Pozdrawiam
> > > > > > Mam inne wyniki. Oto wyniki w formacie dziesiętnym:
> > > > > >
> > > > > > x = 1
> > > > > >
> > > > > > x = (x * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 8222985758604
> > > > > >
> > > > > > 8222985758604 >> 123 = 0
> > > > > >
> > > > > > x = (8222985758604 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 657089637254136791211277
> > > > > >
> > > > > > 657089637254136791211277 >> 123 = 0
> > > > > >
> > > > > > x = (657089637254136791211277 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 52507301369171109219924401511286320
> > > > > >
> > > > > > 52507301369171109219924401511286320 >> 123 = 0
> > > > > >
> > > > > > x = (52507301369171109219924401511286320 * 79908886691 + 8143076871913) &
340282366920938463463374607431768211455 = 333442790507095493699328894974793383801
> > > > > >
> > > > > > 333442790507095493699328894974793383801 >> 123 = 31
> > > > > >
> > > > > > x = (333442790507095493699328894974793383801 * 79908886691 +
8143076871913) & 340282366920938463463374607431768211455 =
225174366013576153541971350915313012980
> > > > > >
> > > > > > 225174366013576153541971350915313012980 >> 123 = 21
> > > > > >
> > > > > > Czyli uzyskuję:
> > > > > >
> > > > > > 0
> > > > > > 0
> > > > > > 0
> > > > > > 31
> > > > > > 21
> > > > > >
> > > > > > I tak dalej. Jak mogą tu wychodzić inne wyniki?
> > > > > Jeśli nie ma błędów, to w tym przypadku nie można uzyskać innych wyników.
Jeśli nie pomijam 100 początkowych
> > > > > wygenerowanych liczb, to mam takie same liczby jak Ty:
> > > > > 0
> > > > > 0
> > > > > 0
> > > > > 31
> > > > > 21
> > > > > 4
> > > > > 3
> > > > > 9
> > > > > 9
> > > > > 7
> > > > > 25
> > > > > 12
> > > > > 15
> > > > > 16
> > > > > 24
> > > > > 11
> > > > > 20
> > > > > 14
> > > > > 25
> > > > > 27
> > > > >
> > > > > Jeśli pomijam to mam takie:
> > > > >
> > > > > 3
> > > > > 29
> > > > > 24
> > > > > 7
> > > > > 24
> > > > > 11
> > > > > 15
> > > > > 18
> > > > > 22
> > > > > 24
> > > > > 17
> > > > > 7
> > > > > 15
> > > > > 0
> > > > > 28
> > > > > 19
> > > > > 8
> > > > > 27
> > > > > 31
> > > > > 0
> > > > >
> > > > > W wielu generatorach początkowe liczby uznawane są za kiepskie. Jeśli to
jest ważne, pomija
> > > > > się wiele początkowych liczb. Ten generator jest tylko do minimalnego
sprawdzenia, ale jakoś
> > > > > odruchowo pominąłem chociaż 100 początkowych liczb. Generalnie, pobieranie
co N-tego bitu to
> > > > > najprostsza technika zwiększająca jakość generatora - ale spowalniająca
generator.
> > > > Wychodzi nam to samo, myślałem, że pominąłem pierwsze 500 bitów, a pominąłeś
100. Oczywiście zdaję sobie sprawę z tych słabości początkowych bitów, sam
projektowałem moje generatory, żeby unikać podobnych problemów. Niemniej mam
przekonanie, że nawet bez pominięcia pierwszych bitów ten generator też dobrze by
sobie poradził.
> > > >
> > > > Ale mniejsza z tym. Mamy te same generatory i ewidentnie problem jest z
formatem danych.
> > > Super, zawęziłeś obszar w którym jest problem :)
> > >
> > > Pozdrawiam
> > Czy możesz mi powiedzieć co konkretnie robisz z uzyskaną liczbą w formacie
dziesiętnym w C++, że zamieniasz ją na format binarny (ten właściwy format, nie
stringa binarnego jak w Pythonie). Spróbuję popytać i znaleźć tego odpowiednik w
Pythonie.
> Nie wiem jak mogę pomóc i trochę się gubię kiedy jaki dokładnie format masz na
myśli :)
>
> Zobacz, poniżej jest format binarny, bo ma same zera i jedynki:
> 01010111010101001001010
> Ale przecież czytasz to jako tekst, więc może to jest format tekstowy? ;-)

Ja sam już nie wiem co to jest. To jest oczywiście format binarny, ale jak się to
wypisuje, to są to ostatecznie znaki ASCII. Więc w bitach, to nie będzie ten sam
ciąg, pomimo, że to nie jest ostatecznie ciąg bitów, tylko zer i jedynek w ASCII.

> Może tego szukasz:
>
> https://stackoverflow.com/questions/908331/how-to-wr
ite-binary-data-to-stdout-in-python-3
>
> import sys
> sys.stdout.buffer.write(b"some binary data")

Dzisiaj to testowałem. Próbowałem:

sys.stdout.buffer.write(b"binary")

gdzie binary to moja liczba zapisana binarnie za pomocą:

split=[(w >> x) & 0xFFFFFFFF for x in reversed(range(0, 128, 32))]

binary = struct.pack('qqqq', split[0], split[1], split[2], split[3])

Ale to skutkuje tylko wypisaniem:

binarybinarybinarybinarybinarybinarybinarybinarybina
rybinarybinarybinarybinarybinarybinarybinarybinarybi
narybinarybinarybinarybinarybinarybinarybinarybinary
binarybinarybinarybinarybinarybinarybinarybinarybina
rybinarybinarybinarybinarybinarybinarybinarybinarybi
narybinarybinarybinarybinarybinarybinarybinarybinary
binarybinarybinarybinarybinarybinarybinarybinarybina
rybinarybinarybinarybinarybinarybinarybinarybinarybi
narybinarybinarybinarybinarybinary

Natomiast sys.stdout.buffer.write(binary) nie działa, oblewa testy jak zwykle.

do góry

PS Na pewno ładuję do sys.stdout.buffer.write() bajty albo "bytes-like objects", bo,
gdy próbuję tam umieścić zwykłe binary, typu binary = 101010101111, to dostaję błąd:

TypeError: a bytes-like object is required, not 'str'

Więc cokolwiek to znaczy, do sys.stdout.buffer.write() trafiają "bytes-like objects".

do góry

On Monday, August 23, 2021 at 11:19:41 PM UTC+2, o...@g...com wrote:
> Widzę jeszcze możliwość problemu z tym jak pociąłem liczby 128-bitowe:
> split=[(w >> x) & 0xFFFFFFFF for x in reversed(range(0, 128, 32))]
>
> binary = struct.pack('qqqq', split[0], split[1], split[2], split[3])
> Pociąłem je na liczby 32 bitowe i w strukt.pack użyłem formatu C Type nazwanego
'q', który oznacza long long:
>
> https://docs.python.org/3/library/struct.html
>
> Jeżeli long long może być dłuższy niż to co tam umieszczam, struct.pack może
wypełniać resztę np. zerami. Ale long long ma chyba właśnie 32-bity.

Nie wiem, to może tam Ciebie coś zainspiruje:

https://stackoverflow.com/questions/4670350/how-do-i
-write-a-long-integer-as-binary-in-python

Pozdrawiam

do góry

poniedziałek, 23 sierpnia 2021 o 23:46:50 UTC+2 M.M. napisał(a):
> On Monday, August 23, 2021 at 11:19:41 PM UTC+2, o...@g...com wrote:
> > Widzę jeszcze możliwość problemu z tym jak pociąłem liczby 128-bitowe:
> > split=[(w >> x) & 0xFFFFFFFF for x in reversed(range(0, 128, 32))]
> >
> > binary = struct.pack('qqqq', split[0], split[1], split[2], split[3])
> > Pociąłem je na liczby 32 bitowe i w strukt.pack użyłem formatu C Type nazwanego
'q', który oznacza long long:
> >
> > https://docs.python.org/3/library/struct.html
> >
> > Jeżeli long long może być dłuższy niż to co tam umieszczam, struct.pack może
wypełniać resztę np. zerami. Ale long long ma chyba właśnie 32-bity.
> Nie wiem, to może tam Ciebie coś zainspiruje:
>
> https://stackoverflow.com/questions/4670350/how-do-i
-write-a-long-integer-as-binary-in-python
>
> Pozdrawiam

Mam błąd:

"ModuleNotFoundError: No module named 'bitarray'"

którego nie da się rozwiązać. Zainstalowałem bitarray i dalej mam ten problem. Google
nie ma to więcej rozwiązań.

do góry

Inna metoda z tego wątku:

def binify(x):
h = hex(x)[2:].rstrip('L')
return binascii.unhexlify('0'*(32-len(h))+h)

Też nie działa.

do góry