To też nie działa:

def to_bytes(num, size):
x = num if num >= 0 else 256**size + num
h = hex(x)[2:].rstrip("L")
return binascii.unhexlify("0"*((2*size)-len(h))+h)

Wyniki, które otrzymuję są podobne do tego, który podano w przykładzie:

\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
\x00\x00\x00'

Oznacza, to, że prawie na pewno konwertuję dane dobrze. Problem jest nadal z
przekazaniem tego do PractRand. Nie wiem, czy używam poprawnie:

sys.stdout.buffer.write(binary)

Skoro nie działa, ale z tego co widzę może tam być po prostu zmienna w nawiasach,
więc nie powinno być problemu. Standardowy print zarówno ze znakami nowej linii, jak
i bez nie działa. Nie sądzę, że tutaj też jest nadal jakiś błąd. Wydaje mi się, że
dane są wciąż źle podawane.

Jak podaje dane program:

#include <cstdio>
#include <cstdint>

#include <random>

int main()
{
freopen(NULL, "wb", stdout); // Only necessary on Windows, but harmless.

std::mt19937 rng(42);

while (1) {
uint32_t value = rng();
fwrite((void*) &value, sizeof(value), 1, stdout);
}
}

https://www.pcg-random.org/posts/how-to-test-with-pr
actrand.html

I czym to się różni od mojego sposobu?

do góry

wtorek, 24 sierpnia 2021 o 11:46:47 UTC+2 M.M. napisał(a):
> On Tuesday, August 24, 2021 at 1:43:54 AM UTC+2, o...@g...com wrote:
> > To też nie działa:
> >
> > def to_bytes(num, size):
> > x = num if num >= 0 else 256**size + num
> > h = hex(x)[2:].rstrip("L")
> > return binascii.unhexlify("0"*((2*size)-len(h))+h)
> >
> > Wyniki, które otrzymuję są podobne do tego, który podano w przykładzie:
> >
> > \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
\x00\x00\x00'
> >
> > Oznacza, to, że prawie na pewno konwertuję dane dobrze. Problem jest nadal z
przekazaniem tego do PractRand. Nie wiem, czy używam poprawnie:
> >
> > sys.stdout.buffer.write(binary)
> >
> > Skoro nie działa, ale z tego co widzę może tam być po prostu zmienna w nawiasach,
więc nie powinno być problemu. Standardowy print zarówno ze znakami nowej linii, jak
i bez nie działa. Nie sądzę, że tutaj też jest nadal jakiś błąd. Wydaje mi się, że
dane są wciąż źle podawane.
> >
> > Jak podaje dane program:
> >
> > #include <cstdio>
> > #include <cstdint>
> >
> > #include <random>
> >
> > int main()
> > {
> > freopen(NULL, "wb", stdout); // Only necessary on Windows, but harmless.
> >
> > std::mt19937 rng(42);
> >
> > while (1) {
> > uint32_t value = rng();
> > fwrite((void*) &value, sizeof(value), 1, stdout);
> > }
> > }
> >
> > https://www.pcg-random.org/posts/how-to-test-with-pr
actrand.html
> >
> > I czym to się różni od mojego sposobu?
> Nie wiem, ale u mnie działa:
>
> cat test.py
> import sys
> import struct
>
> class SimpPRNG:
> x = 0
> A = 79908886691
> B = 8143076871913
> def __init__( self, seed ):
> self.x = seed
> for i in range(1,100):
> self.g()
>
> def g(self):
> self.x = (self.x * self.A + self.B) & (2**128-1)
> return self.x >> 123
>
> r = SimpPRNG( 1 )
> buf = 0
> s = 0
> while True:
> t = r.g()
> for i in range(1,5):
> buf = buf << 1
> buf = buf | (t & 1)
> t = t >> 1
> s = s + 1
> if s == 32:
> sys.stdout.write( struct.pack('I', buf) )
> s = 0
> buf = 0
>
>
> python test.py | ../c/PractRand/RNG_test stdin
> RNG_test using PractRand version 0.94
> RNG = RNG_stdin, seed = unknown
> test set = core, folding = standard(unknown format)
>
> rng=RNG_stdin, seed=unknown
> length= 512 kilobytes (2^19 bytes), time= 2.7 seconds
> no anomalies in 84 test result(s)
>
> rng=RNG_stdin, seed=unknown
> length= 1 megabyte (2^20 bytes), time= 5.8 seconds
> no anomalies in 94 test result(s)
>
> rng=RNG_stdin, seed=unknown
> length= 2 megabytes (2^21 bytes), time= 11.5 seconds
> no anomalies in 109 test result(s)
>
> rng=RNG_stdin, seed=unknown
> length= 4 megabytes (2^22 bytes), time= 22.7 seconds
> no anomalies in 124 test result(s)
>
> rng=RNG_stdin, seed=unknown
> length= 8 megabytes (2^23 bytes), time= 44.5 seconds
> no anomalies in 135 test result(s)
>
> rng=RNG_stdin, seed=unknown
> length= 16 megabytes (2^24 bytes), time= 87.8 seconds
> no anomalies in 151 test result(s)
> ^CTraceback (most recent call last):
> File "test.py", line 30, in <module>
> t = t >> 1
> KeyboardInterrupt
>
> Pozdrawim

U mnie sys.stdout.write(struct.pack('I', buf)) od razu podświetla się jako błąd. Po
uruchomieniu:

TypeError: write() argument must be str, not bytes

Gdy zrobię z argumentu stringa sys.stdout.write(str(struct.pack('I', buf))), to
oczywiście oblewa. Trzeba tam jeszcze coś prawdopodobnie dodać, żeby to write
działało w trybie binarnym.

do góry

Jest pewien przełom. Napisałem:

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

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

sys.stdout.buffer.write(binary)

Czyli zmieniłem 'LLLL' , które już testowałem na 'IIII' i otrzymałem:

RNG_test using PractRand version 0.93
RNG = RNG_stdin, seed = 0x974d705a
test set = normal, folding = standard(unknown format)

rng=RNG_stdin, seed=0x974d705a
length= 16 megabytes (2^24 bytes), time= 2.5 seconds
no anomalies in 119 test result(s)

free(): invalid size
Traceback (most recent call last):
File "Mojgenerator.py", line 73, in <module>
sys.stdout.buffer.write(binary)
BrokenPipeError: [Errno 32] Broken pipe
Exception ignored in: <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>
BrokenPipeError: [Errno 32] Broken pipe
Aborted (core dumped)

Z jakichś powodów testy zostały zakończone, a powinno się testować zdaje się dalej,
aż do czasu, gdy obleje?

do góry

wtorek, 24 sierpnia 2021 o 18:15:49 UTC+2 M.M. napisał(a):
> On Tuesday, August 24, 2021 at 5:49:14 PM UTC+2, o...@g...com wrote:
> > Jest pewien przełom. Napisałem:
> >
> > split=[(w >> x) & 0xFFFFFFFF for x in reversed(range(0, 128, 32))]
> >
> > binary = struct.pack('IIII', split[0], split[1], split[2], split[3])
> >
> > sys.stdout.buffer.write(binary)
> >
> > Czyli zmieniłem 'LLLL' , które już testowałem na 'IIII' i otrzymałem:
> > RNG_test using PractRand version 0.93
> > RNG = RNG_stdin, seed = 0x974d705a
> > test set = normal, folding = standard(unknown format)
> >
> > rng=RNG_stdin, seed=0x974d705a
> > length= 16 megabytes (2^24 bytes), time= 2.5 seconds
> > no anomalies in 119 test result(s)
> >
> > free(): invalid size
> > Traceback (most recent call last):
> > File "Mojgenerator.py", line 73, in <module>
> > sys.stdout.buffer.write(binary)
> > BrokenPipeError: [Errno 32] Broken pipe
> > Exception ignored in: <_io.TextIOWrapper name='<stdout>' mode='w'
encoding='utf-8'>
> > BrokenPipeError: [Errno 32] Broken pipe
> > Aborted (core dumped)
> >
> > Z jakichś powodów testy zostały zakończone, a powinno się testować zdaje się
dalej, aż do czasu, gdy obleje?
> Może spróbuj wersję 0.94.
> Pozdrawiam

Jak ją zainstalować? Instrukcje do poprzedniej mam stąd:

https://www.pcg-random.org/posts/how-to-test-with-pr
actrand.html

Działanie samego programu w konsoli również kończy się szybko. Po wypisaniu kilku
krzaków, dostaję błąd:

Traceback (most recent call last):
File "Collatzgenerator01.py", line 63, in <module>
sys.stdout.buffer.write(binary)
OSError: [Errno 5] Input/output error
Exception ignored in: <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>
OSError: [Errno 5] Input/output error

Takiego zatrzymania nie ma w PyCharmie. Co sugeruje, że program stwarza z jakichś
powodów problem dla konsoli. Coś z przepełnieniem pamięci, z tego co czytam.
Korzystam z konsoli Linuxowej (Ubuntu) na Windowsa. Może tu jest problem. Rozwiązania
znalezione w sieci jak na razie nie działają.

do góry

To działa:

"run your python scripts with I/O redirection that discards output:

python foo.py >/dev/null 2>&1"

https://stackoverflow.com/questions/38238139/python-
prevent-ioerror-errno-5-input-output-error-when-runn
ing-without-stdo

To znaczy konsola niczego nie wyświetla i wygląda na to, że program działa.
Napisanie:

python3 Mojgenerator.py >/dev/null 2>&1 ? | ./RNG_test stdin

Skutkuje wyświetleniem:

RNG_test using PractRand version 0.93
RNG = RNG_stdin, seed = 0x2d4abc91
test set = normal, folding = standard(unknown format)

I miganiem kursora. Coś więc cały czas działa lub na coś czeka.

do góry

W cmder ten sam problem. 'RNG_test' is not recognized as an internal or external
command, operable program or batch file.

Także w cmd mój generator chodzi, ale nie działa PractRand, a w konsoli Ubuntu mój
generator nie chodzi, ale za to chodzi PractRand. Genialnie.

do góry

Mogę otwierać szampana, a nawet dwa. Zaktualizowałem wersję do 0.94 - nie pomogło,
ale aktualizacja do 0.95 pomogła. Była to w takim razie prawdopodobnie wyłącznie wina
testów, nie moja, nie konsoli, nie Pythona.

Mój generator zdaje testy:

RNG_test using PractRand version 0.95
RNG = RNG_stdin, seed = unknown
test set = core, folding = standard(unknown format)

rng=RNG_stdin, seed=unknown
length= 16 megabytes (2^24 bytes), time= 2.5 seconds
no anomalies in 153 test result(s)

rng=RNG_stdin, seed=unknown
length= 32 megabytes (2^25 bytes), time= 6.5 seconds
no anomalies in 169 test result(s)

rng=RNG_stdin, seed=unknown
length= 64 megabytes (2^26 bytes), time= 12.9 seconds
no anomalies in 182 test result(s)

rng=RNG_stdin, seed=unknown
length= 128 megabytes (2^27 bytes), time= 24.3 seconds
no anomalies in 199 test result(s)

rng=RNG_stdin, seed=unknown
length= 256 megabytes (2^28 bytes), time= 45.5 seconds
no anomalies in 217 test result(s)

rng=RNG_stdin, seed=unknown
length= 512 megabytes (2^29 bytes), time= 86.5 seconds
no anomalies in 232 test result(s)

rng=RNG_stdin, seed=unknown
length= 1 gigabyte (2^30 bytes), time= 167 seconds
no anomalies in 251 test result(s)

rng=RNG_stdin, seed=unknown
length= 2 gigabytes (2^31 bytes), time= 327 seconds
no anomalies in 269 test result(s)

rng=RNG_stdin, seed=unknown
length= 4 gigabytes (2^32 bytes), time= 645 seconds
no anomalies in 283 test result(s)

rng=RNG_stdin, seed=unknown
length= 8 gigabytes (2^33 bytes), time= 1283 seconds
no anomalies in 300 test result(s)

rng=RNG_stdin, seed=unknown
length= 16 gigabytes (2^34 bytes), time= 2557 seconds
no anomalies in 315 test result(s)

rng=RNG_stdin, seed=unknown
length= 32 gigabytes (2^35 bytes), time= 5096 seconds
no anomalies in 328 test result(s)

rng=RNG_stdin, seed=unknown
length= 64 gigabytes (2^36 bytes), time= 10170 seconds
no anomalies in 344 test result(s)

rng=RNG_stdin, seed=unknown
length= 128 gigabytes (2^37 bytes), time= 20316 seconds
no anomalies in 359 test result(s)

Aczkolwiek trzeba ich pewnie zrobić przynajmniej 2^40 bajtów. Jestem pewien, że
gdzieś powyżej 128 GB konsola mi się wyłączyła, pomimo, że zostawiłem ją na noc
włączoną, razem z laptopem. Mam nadzieję, że sytuacja się nie powtórzy i był to
przypadek.

do góry

poniedziałek, 30 sierpnia 2021 o 21:38:50 UTC+2 M.M. napisał(a):
> On Sunday, August 29, 2021 at 4:29:12 PM UTC+2, o...@g...com wrote:
> > Mogę otwierać szampana, a nawet dwa. Zaktualizowałem wersję do 0.94 - nie
pomogło, ale aktualizacja do 0.95 pomogła. Była to w takim razie prawdopodobnie
wyłącznie wina testów, nie moja, nie konsoli, nie Pythona.
> >
> > Mój generator zdaje testy:
> >
> > RNG_test using PractRand version 0.95
> > RNG = RNG_stdin, seed = unknown
> > test set = core, folding = standard(unknown format)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 16 megabytes (2^24 bytes), time= 2.5 seconds
> > no anomalies in 153 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 32 megabytes (2^25 bytes), time= 6.5 seconds
> > no anomalies in 169 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 64 megabytes (2^26 bytes), time= 12.9 seconds
> > no anomalies in 182 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 128 megabytes (2^27 bytes), time= 24.3 seconds
> > no anomalies in 199 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 256 megabytes (2^28 bytes), time= 45.5 seconds
> > no anomalies in 217 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 512 megabytes (2^29 bytes), time= 86.5 seconds
> > no anomalies in 232 test result(s)
> > rng=RNG_stdin, seed=unknown
> > length= 1 gigabyte (2^30 bytes), time= 167 seconds
> > no anomalies in 251 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 2 gigabytes (2^31 bytes), time= 327 seconds
> > no anomalies in 269 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 4 gigabytes (2^32 bytes), time= 645 seconds
> > no anomalies in 283 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 8 gigabytes (2^33 bytes), time= 1283 seconds
> > no anomalies in 300 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 16 gigabytes (2^34 bytes), time= 2557 seconds
> > no anomalies in 315 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 32 gigabytes (2^35 bytes), time= 5096 seconds
> > no anomalies in 328 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 64 gigabytes (2^36 bytes), time= 10170 seconds
> > no anomalies in 344 test result(s)
> >
> > rng=RNG_stdin, seed=unknown
> > length= 128 gigabytes (2^37 bytes), time= 20316 seconds
> > no anomalies in 359 test result(s)
> >
> > Aczkolwiek trzeba ich pewnie zrobić przynajmniej 2^40 bajtów. Jestem pewien, że
gdzieś powyżej 128 GB konsola mi się wyłączyła, pomimo, że zostawiłem ją na noc
włączoną, razem z laptopem. Mam nadzieję, że sytuacja się nie powtórzy i był to
przypadek.
> Gratulacje.
>
> Kilka pytań:
>
> Czy możesz gdzieś zamieścić zrozumiały kod samego (wyizolowanego) generatora w
> celu przeczytania kodu?
>
> Jakimi generatorami i generalnie jakim algorytmami wzorowałeś się podczas pisania
tego generatora?
>
> Czy mogę Twój generator dorzucić do mojej biblioteki i zrobić testy takie jak
innych generatorów? - ale to
> kiedyś w przyszłości, pod warunkiem że znajdę czas i będę miał jakiś serwer do
testów.
>
> Pozdrawiam

Mam pewne plany co do tych generatorów i właściwie aktualnie szukam możliwości ich
publikacji lub komercjalizacji, dlatego z publikacją wolałbym zaczekać. Te generatory
są dosyć interesującym wynalazkiem z kilku powodów:
- inspiracją były ciągi Collatza i pewne generalizacje tego rodzaju funkcji, teoria
stojąca za tymi generatorami jest moim zdaniem naprawdę ciekawa,
- generatory mają klucze, ale są łatwo odwracalne i same w sobie nie są
kryptograficznie bezpieczne, jakkolwiek można ich użyć jako budulców algorytmu
szyfrującego (stworzyłem taki algorytm),
- wciąż są słabo poznane, poza tym, że dla kilku przetestowanych kluczy generowały
dobre wyniki, nie ma teorii, która określałaby ich okres (dla prawdziwie losowej
n-elementowej permutacji spodziewamy się okresu (n+1)/2, ale to założenie będzie
prawdziwe, jeśli generator daje bardzo dobrej jakości liczby pseudolosowe),
- potrafią generować bloki dowolnej wielkości, przy użyciu odpowiednio dużych kluczy,
- są szybkie (okolice prędkości uzyskiwanych przez generatory PCG).

do góry

On Tuesday, August 31, 2021 at 12:57:36 AM UTC+2, o...@g...com wrote:
> poniedziałek, 30 sierpnia 2021 o 21:38:50 UTC+2 M.M. napisał(a):
> > On Sunday, August 29, 2021 at 4:29:12 PM UTC+2, o...@g...com wrote:
> > > Mogę otwierać szampana, a nawet dwa. Zaktualizowałem wersję do 0.94 - nie
pomogło, ale aktualizacja do 0.95 pomogła. Była to w takim razie prawdopodobnie
wyłącznie wina testów, nie moja, nie konsoli, nie Pythona.
> > >
> > > Mój generator zdaje testy:
> > >
> > > RNG_test using PractRand version 0.95
> > > RNG = RNG_stdin, seed = unknown
> > > test set = core, folding = standard(unknown format)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 16 megabytes (2^24 bytes), time= 2.5 seconds
> > > no anomalies in 153 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 32 megabytes (2^25 bytes), time= 6.5 seconds
> > > no anomalies in 169 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 64 megabytes (2^26 bytes), time= 12.9 seconds
> > > no anomalies in 182 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 128 megabytes (2^27 bytes), time= 24.3 seconds
> > > no anomalies in 199 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 256 megabytes (2^28 bytes), time= 45.5 seconds
> > > no anomalies in 217 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 512 megabytes (2^29 bytes), time= 86.5 seconds
> > > no anomalies in 232 test result(s)
> > > rng=RNG_stdin, seed=unknown
> > > length= 1 gigabyte (2^30 bytes), time= 167 seconds
> > > no anomalies in 251 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 2 gigabytes (2^31 bytes), time= 327 seconds
> > > no anomalies in 269 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 4 gigabytes (2^32 bytes), time= 645 seconds
> > > no anomalies in 283 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 8 gigabytes (2^33 bytes), time= 1283 seconds
> > > no anomalies in 300 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 16 gigabytes (2^34 bytes), time= 2557 seconds
> > > no anomalies in 315 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 32 gigabytes (2^35 bytes), time= 5096 seconds
> > > no anomalies in 328 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 64 gigabytes (2^36 bytes), time= 10170 seconds
> > > no anomalies in 344 test result(s)
> > >
> > > rng=RNG_stdin, seed=unknown
> > > length= 128 gigabytes (2^37 bytes), time= 20316 seconds
> > > no anomalies in 359 test result(s)
> > >
> > > Aczkolwiek trzeba ich pewnie zrobić przynajmniej 2^40 bajtów. Jestem pewien, że
gdzieś powyżej 128 GB konsola mi się wyłączyła, pomimo, że zostawiłem ją na noc
włączoną, razem z laptopem. Mam nadzieję, że sytuacja się nie powtórzy i był to
przypadek.
> > Gratulacje.
> >
> > Kilka pytań:
> >
> > Czy możesz gdzieś zamieścić zrozumiały kod samego (wyizolowanego) generatora w
> > celu przeczytania kodu?
> >
> > Jakimi generatorami i generalnie jakim algorytmami wzorowałeś się podczas pisania
tego generatora?
> >
> > Czy mogę Twój generator dorzucić do mojej biblioteki i zrobić testy takie jak
innych generatorów? - ale to
> > kiedyś w przyszłości, pod warunkiem że znajdę czas i będę miał jakiś serwer do
testów.
> >
> > Pozdrawiam
> Mam pewne plany co do tych generatorów i właściwie aktualnie szukam możliwości ich
publikacji lub komercjalizacji, dlatego z publikacją wolałbym zaczekać. Te generatory
są dosyć interesującym wynalazkiem z kilku powodów:
> - inspiracją były ciągi Collatza i pewne generalizacje tego rodzaju funkcji, teoria
stojąca za tymi generatorami jest moim zdaniem naprawdę ciekawa,
> - generatory mają klucze, ale są łatwo odwracalne i same w sobie nie są
kryptograficznie bezpieczne, jakkolwiek można ich użyć jako budulców algorytmu
szyfrującego (stworzyłem taki algorytm),
> - wciąż są słabo poznane, poza tym, że dla kilku przetestowanych kluczy generowały
dobre wyniki, nie ma teorii, która określałaby ich okres (dla prawdziwie losowej
n-elementowej permutacji spodziewamy się okresu (n+1)/2, ale to założenie będzie
prawdziwe, jeśli generator daje bardzo dobrej jakości liczby pseudolosowe),
> - potrafią generować bloki dowolnej wielkości, przy użyciu odpowiednio dużych
kluczy,
> - są szybkie (okolice prędkości uzyskiwanych przez generatory PCG).

Jeszcze jedno, w sieci coś jest o generatorach na bazie ciągu collatza:
https://link.springer.com/article/10.1007/s41870-019
-00307-9

do góry

wtorek, 31 sierpnia 2021 o 02:31:07 UTC+2 M.M. napisał(a):
> On Tuesday, August 31, 2021 at 12:57:36 AM UTC+2, o...@g...com wrote:
> > poniedziałek, 30 sierpnia 2021 o 21:38:50 UTC+2 M.M. napisał(a):
> > > On Sunday, August 29, 2021 at 4:29:12 PM UTC+2, o...@g...com wrote:
> > > > Mogę otwierać szampana, a nawet dwa. Zaktualizowałem wersję do 0.94 - nie
pomogło, ale aktualizacja do 0.95 pomogła. Była to w takim razie prawdopodobnie
wyłącznie wina testów, nie moja, nie konsoli, nie Pythona.
> > > >
> > > > Mój generator zdaje testy:
> > > >
> > > > RNG_test using PractRand version 0.95
> > > > RNG = RNG_stdin, seed = unknown
> > > > test set = core, folding = standard(unknown format)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 16 megabytes (2^24 bytes), time= 2.5 seconds
> > > > no anomalies in 153 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 32 megabytes (2^25 bytes), time= 6.5 seconds
> > > > no anomalies in 169 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 64 megabytes (2^26 bytes), time= 12.9 seconds
> > > > no anomalies in 182 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 128 megabytes (2^27 bytes), time= 24.3 seconds
> > > > no anomalies in 199 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 256 megabytes (2^28 bytes), time= 45.5 seconds
> > > > no anomalies in 217 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 512 megabytes (2^29 bytes), time= 86.5 seconds
> > > > no anomalies in 232 test result(s)
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 1 gigabyte (2^30 bytes), time= 167 seconds
> > > > no anomalies in 251 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 2 gigabytes (2^31 bytes), time= 327 seconds
> > > > no anomalies in 269 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 4 gigabytes (2^32 bytes), time= 645 seconds
> > > > no anomalies in 283 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 8 gigabytes (2^33 bytes), time= 1283 seconds
> > > > no anomalies in 300 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 16 gigabytes (2^34 bytes), time= 2557 seconds
> > > > no anomalies in 315 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 32 gigabytes (2^35 bytes), time= 5096 seconds
> > > > no anomalies in 328 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 64 gigabytes (2^36 bytes), time= 10170 seconds
> > > > no anomalies in 344 test result(s)
> > > >
> > > > rng=RNG_stdin, seed=unknown
> > > > length= 128 gigabytes (2^37 bytes), time= 20316 seconds
> > > > no anomalies in 359 test result(s)
> > > >
> > > > Aczkolwiek trzeba ich pewnie zrobić przynajmniej 2^40 bajtów. Jestem pewien,
że gdzieś powyżej 128 GB konsola mi się wyłączyła, pomimo, że zostawiłem ją na noc
włączoną, razem z laptopem. Mam nadzieję, że sytuacja się nie powtórzy i był to
przypadek.
> > > Gratulacje.
> > >
> > > Kilka pytań:
> > >
> > > Czy możesz gdzieś zamieścić zrozumiały kod samego (wyizolowanego) generatora w
> > > celu przeczytania kodu?
> > >
> > > Jakimi generatorami i generalnie jakim algorytmami wzorowałeś się podczas
pisania tego generatora?
> > >
> > > Czy mogę Twój generator dorzucić do mojej biblioteki i zrobić testy takie jak
innych generatorów? - ale to
> > > kiedyś w przyszłości, pod warunkiem że znajdę czas i będę miał jakiś serwer do
testów.
> > >
> > > Pozdrawiam
> > Mam pewne plany co do tych generatorów i właściwie aktualnie szukam możliwości
ich publikacji lub komercjalizacji, dlatego z publikacją wolałbym zaczekać. Te
generatory są dosyć interesującym wynalazkiem z kilku powodów:
> > - inspiracją były ciągi Collatza i pewne generalizacje tego rodzaju funkcji,
teoria stojąca za tymi generatorami jest moim zdaniem naprawdę ciekawa,
> > - generatory mają klucze, ale są łatwo odwracalne i same w sobie nie są
kryptograficznie bezpieczne, jakkolwiek można ich użyć jako budulców algorytmu
szyfrującego (stworzyłem taki algorytm),
> > - wciąż są słabo poznane, poza tym, że dla kilku przetestowanych kluczy
generowały dobre wyniki, nie ma teorii, która określałaby ich okres (dla prawdziwie
losowej n-elementowej permutacji spodziewamy się okresu (n+1)/2, ale to założenie
będzie prawdziwe, jeśli generator daje bardzo dobrej jakości liczby pseudolosowe),
> > - potrafią generować bloki dowolnej wielkości, przy użyciu odpowiednio dużych
kluczy,
> > - są szybkie (okolice prędkości uzyskiwanych przez generatory PCG).
> Brzmi ciekawiej i bardziej poważnie niż początkowo sądziłem. Myślałem że to czysta
> zabawa czymś znacznie prostszym od strony teoretycznej, dlatego poprosiłem o
wcielenie
> tego generatora do mojej biblioteki - przepraszam.

Nie ma problemu, trochę głupio mi, że nie mogę powiedzieć o co chodzi, tym bardziej,
że trochę czasu nad tematem tu spędziliśmy. Ale pewnie rozumiesz, że, jeśli to kiedyś
ma zostać formalnie opublikowane, to źle by wyglądało, gdyby hulało w jakiejś
roboczej wersji po Internecie. A, jeśli się nie mylę, to ma to wystarczający
potencjał, by konkurować nowoczesnymi generatorami liczb pseudolosowych. To, czy
doprowadzę publikację lub komercyjne badania (może patent) nad tym do końca, to
osobna sprawa.

> Życzę zatem udanej publikacji i pozdrawiam.
>
>
> Nawiasem pisząc, mi się spodobał generator whyhash. Dostałem do niego link
> tutaj na grupie. Jest ekstremalnie prosty, a zatem i ekstremalnie szybki:
>
> https://github.com/mmarszik/MRndCPP/blob/master/rnd_
wyhash64.h

Wygląda ciekawie, nigdy wcześniej nie sprawdzałem jak działa, ale obił mi się o uszy.
Moje zainteresowania kręcą się wokół generatorów LCG i PCG (autorstwa Melissy
O'Neil), z pewnych powodów mają one sporo wspólnego ze wspomnianymi ciągami.

> Jeszcze jedno, w sieci coś jest o generatorach na bazie ciągu collatza:
> https://link.springer.com/article/10.1007/s41870-019
-00307-9

Kojarzę tę publikację. Zaczynałem od podobnych konstrukcji. Nie testowałem ich
generatora, bo ostatnio, gdy ją czytałem nie zrozumiałem wszystkiego, ale teraz
widzę, że ten ich generator musi być dosyć wolny. Metoda, której użyli jest dosyć
typowa i to zdecydowanie dobry trop na wyłuskanie pseudolosowości z tych ciągów.
Ogólnie ad vocem, powoli coś się dzieje wokół tematu i coraz więcej naukowców próbuje
węszyć jakieś zastosowania ciągów Collatza w kontekście ich pseudolosowych
właściwości. Podobne rzeczy próbowało patentować Apple:

https://patents.google.com/patent/US20130108038A1/en

Natomiast ciekawą funkcję one way zaproponowano tutaj:

https://arxiv.org/pdf/1801.05079.pdf

We wszystkich tych publikacjach chodzi głównie o te wektory kodujące "encoding
vector". To jest dobre rozwiązanie, ale to za mało, głównie dlatego, że jest to
wolne. Policzenie takiego wektora wymaga na przykład 128 iteracji w ciągu Collatza
(na liczbach blisko 128-bitowych), z czego uzyskujemy zaledwie liczbę 128-bitową (i
wciąż nieidealną, w rzeczywistości ma dużo wad, jeśli chodzi o losowość bitów).
Bardzo kosztowny obliczeniowo sposób. Usprawniłem go. Ale nie ukrywam, że zwłaszcza
publikacja "One Way Function Candidate based on the Collatz Problem" była dla mnie
inspiracją, choć pracowałem nad tym już wcześniej i doskonale zdawałem sobie sprawę
co tam się na tych bitach dzieje. Oczywiście pisząc "pracowałem" mam wciąż na myśli,
że robiłem to amatorsko, nie jestem matematykiem, ani programistą.

do góry