Numpy: Numpy द्वारा प्रदान किए गए PCG कार्यान्वयन में महत्वपूर्ण, खतरनाक आत्म-सहसंबंध हैं

@imneme , @bashtage , @rkern यहां के अधिकारी होंगे, लेकिन मुझे लगता है कि हम इस पर आगे बढ़ चुके हैं और यही कारण है कि हमने jumped एक से अधिक SeedSequence.spawn इंटरफ़ेस को प्राथमिकता दी। उदाहरण के लिए जब हम एपीआई पर चर्चा कर रहे थे तो यह चर्चा थी। कृपया यहां सलाह देखें https://numpy.org/devdocs/reference/random/parallel.html और आवश्यकतानुसार सुधार सुझाएं।

@ मट्टीप का जंपिंग से कोई लेना-देना नहीं है।

मुझे लगता है कि व्यवहार में थोक परिवर्तन करना मुश्किल है, हालांकि बेहतर प्रलेखन हमेशा एक अच्छा विचार है।

मैं शायद AES-NI के साथ किसी के लिए AESCounter की सिफारिश करूंगा या अत्यधिक समानांतर सेटिंग्स में बिना किसी के लिए SPECK128 ।

वही अलग-अलग "धाराओं" के साथ हो सकता है, क्योंकि एलसीजी द्वारा एडिटिव स्थिरांक को बदलते हुए उत्पन्न होने वाले क्रम सभी एक ही मोडुलो साइन का परिवर्तन और एक योजक स्थिरांक होते हैं।

क्या आप इसकी मात्रा निर्धारित कर सकते हैं? मैं एक ही वेतन वृद्धि का उपयोग करके विफलताओं को दोहरा सकता हूं, लेकिन हम वेतन वृद्धि के साथ-साथ राज्य को भी प्रभावित करते हैं, और मैंने अभी तक दो अलग-अलग यादृच्छिक वेतन वृद्धि के साथ विफलता नहीं देखी है। अगर वेतन वृद्धि का भी सावधानी से निर्माण करना है, तो यह व्यावहारिक जन्मदिन टक्कर आवृत्ति को प्रभावित करेगा।

https://gist.github.com/rkern/f46552e030e59b5f1ebbd3b3ec045759

❯ ./pcg64_correlations.py --same-increment | stdbuf -oL ./RNG_test stdin64 -tf 2 -te 1 -tlmaxonly -multithreaded
0x56b35656ede2b560587e4251568a8fed
0x93526034ed105e9e587e4251568a8fed
[
    {
        "bit_generator": "PCG64",
        "state": {
            "state": 115244779949650410574112983538102603757,
            "inc": 137507567477557873606783385380908979143
        },
        "has_uint32": 0,
        "uinteger": 0
    },
    {
        "bit_generator": "PCG64",
        "state": {
            "state": 195824235027336627448689568147458133997,
            "inc": 137507567477557873606783385380908979143
        },
        "has_uint32": 0,
        "uinteger": 0
    }
]
RNG_test using PractRand version 0.93
RNG = RNG_stdin64, seed = 0x4bf19f7b
test set = expanded, folding = extra

rng=RNG_stdin64, seed=0x4bf19f7b
length= 128 megabytes (2^27 bytes), time= 3.0 seconds
  Test Name                         Raw       Processed     Evaluation
  BCFN_FF(2+0,13-3,T)               R= +59.9  p =  3.8e-28    FAIL !!!       
  BCFN_FF(2+1):freq                 R= +89.0  p~=   6e-18     FAIL !         
  BCFN_FF(2+2):freq                 R= +39.6  p~=   6e-18     FAIL !         
  BCFN_FF(2+3):freq                 R= +14.6  p~=   6e-18     FAIL !         
  BCFN_FF(2+4):freq                 R= +10.3  p~=   5e-11   very suspicious  
  DC6-9x1Bytes-1                    R=  +7.1  p =  5.6e-4   unusual          
  DC6-6x2Bytes-1                    R= +18.9  p =  1.0e-10   VERY SUSPICIOUS 
  DC6-5x4Bytes-1                    R= +11.2  p =  1.4e-6   suspicious       
  [Low4/16]BCFN_FF(2+0):freq        R= +19.5  p~=   6e-18     FAIL !         
  [Low4/16]FPF-14+6/16:all          R=  +5.6  p =  1.0e-4   unusual          
  [Low4/16]FPF-14+6/4:all           R=  +5.9  p =  4.6e-5   unusual          
  [Low4/32]BCFN_FF(2+0):freq        R=  +6.5  p~=   2e-5    unusual          
  [Low8/32]BCFN_FF(2+0):freq        R= +15.1  p~=   6e-18     FAIL !         
  [Low8/32]FPF-14+6/32:all          R=  +8.4  p =  2.5e-7   very suspicious  
  [Low8/32]FPF-14+6/32:all2         R=  +9.0  p =  7.8e-5   unusual          
  [Low8/32]FPF-14+6/16:(0,14-0)     R= +12.4  p =  4.5e-11   VERY SUSPICIOUS 
  [Low8/32]FPF-14+6/16:all          R= +15.5  p =  5.2e-14    FAIL           
  [Low8/32]FPF-14+6/16:all2         R= +41.4  p =  2.6e-16    FAIL !         
  [Low8/32]FPF-14+6/4:(0,14-0)      R=  +6.9  p =  5.9e-6   unusual          
  [Low8/32]FPF-14+6/4:all           R=  +7.9  p =  6.6e-7   suspicious       
  ...and 871 test result(s) without anomalies

ठीक है, मैं फिर से कोशिश करूँगा।

एलसीजी में पावर-ऑफ -2 मापांक के साथ कई धाराएँ नहीं होती हैं। कई लोगों ने माना कि शुरुआती दिनों में, और यहां तक ​​कि लंबे समय तक पुराने कागजात हैं, जो उन "धाराओं" के साथ दिलचस्प चीजें करने का दावा करते हैं, लेकिन यह दशकों से ज्ञात है कि स्थिरांक बदलकर जो परिक्रमा आप प्राप्त करते हैं, वे एक ही मोडुलो हैं एक योजक स्थिरांक और संभवतः एक साइन चेंज_। सबसे दूर मैं इसे ट्रेस कर सकता हूं

मार्क जे। डर्स्ट, समानांतर यादृच्छिक संख्या पीढ़ी के लिए रैखिक सर्वांगसम जनरेटर का उपयोग करते हुए,
1989 शीतकालीन सिमुलेशन सम्मेलन की कार्यवाही, IEEE प्रेस, 1989, पीपी। 462-466।

तो, मैंने एक और कार्यक्रम लिखा http://prng.di.unimi.it/corrpcgnumpy.c जिसमें आप सेट कर सकते हैं:

• PRNG के लिए एक प्रारंभिक अवस्था।
• एक और PRNG के लिए एक प्रारंभिक अवस्था।
• पहले PRNG के लिए एक मनमाना "स्ट्रीम निरंतर"।
• दूसरे PRNG के लिए एक मनमाना "स्ट्रीम निरंतर" (वे दोनों समान या दोनों विषम होना चाहिए; यह प्रतिबंध कुछ अतिरिक्त फ़िडलिंग के साथ हटाया जा सकता है)।
• निचले बिट्स की एक निश्चित संख्या जिसे हम दूसरे PRNG में प्रतिकूल रूप से सेट करेंगे, अनिवार्य रूप से इस तरह से कि यह पहले PRNG के समान बिट्स से शुरू होता है। आपके द्वारा प्रदान किए गए दूसरे PRNG के लिए शेष बिट्स को प्रारंभिक अवस्था से लिया जाएगा।

तो यह _exactly_ पहले प्रोग्राम की सेटिंग है, लेकिन आप स्थिरांक भी चुन सकते हैं।

./corrpcgnumpy 0x596d84dfefec2fc7 0x6b79f81ab9f3e37b 0xac9c8abfcb89f65f 0xe42e8dff1c46de8b 0x8d7deae9efec2fc7 0x6b79f81ab9f3e37b 0x06e13e5e8c92c843 0xf92e8346feee7a21 56 | stdbuf -oL ~/svn/c/xorshift/practrand/RNG_test stdin -tf 2 -te 1 -tlmaxonly -multithreaded

rng=RNG_stdin, seed=unknown
length= 4 gigabytes (2^32 bytes), time= 113 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/8]BCFN(0+0,13-1,T)          R= +27.2  p =  4.0e-14    FAIL
  [Low1/8]DC6-6x2Bytes-1            R= +10.9  p =  4.4e-6   suspicious
  [Low1/64]DC6-5x4Bytes-1           R=  -6.4  p =1-1.4e-4   unusual
  [Low8/64]FPF-14+6/64:(0,14-0)     R=  +8.4  p =  2.2e-7   mildly suspicious
  [Low8/64]FPF-14+6/64:all          R=  +8.7  p =  1.2e-7   suspicious
  [Low8/64]FPF-14+6/32:(0,14-0)     R= +10.2  p =  5.1e-9   suspicious
  [Low8/64]FPF-14+6/32:all          R=  +9.4  p =  2.7e-8   very suspicious
  [Low8/64]FPF-14+6/16:all          R=  +5.8  p =  6.4e-5   unusual
  ...and 1439 test result(s) without anomalies

तो वहाँ _at कम से कम 2 ^ 72 सहसंबद्ध अनुवर्ती हैं, कोई फर्क नहीं पड़ता कि आप "स्ट्रीम कॉन्स्टेंट" का चयन कैसे करते हैं, बिल्कुल उसी तरह के मामले में।

और हमें जनरेटर को सुस्त मात्रा में दिया जाता है: भले ही सटीक शुरुआती बिंदु के बजाय मैं गणना कर रहा हूं कि आप पहले या बाद में एक राज्य का थोड़ा सा उपयोग करेंगे, सहसंबंध वैसे भी दिखाई देगा। आप ऐसा करने के लिए प्रोग्राम को अतिरिक्त पैरामीटर के साथ आसानी से संशोधित कर सकते हैं।

मैं दोहराता हूं, एक बार फिर: वैज्ञानिक साहित्य के किसी भी मौजूदा आधुनिक जनरेटर में यह दुर्व्यवहार नहीं है (बेशक, एक पावर-टू एलसीजी में यह व्यवहार है, लेकिन, भगवान के लिए, यह _not_ एक आधुनिक जनरेटर है)।

इस ब्लॉग पोस्ट में 2018 से सबस्टियानो के PCG की आलोचना की गई है।

संक्षिप्त संस्करण यह है कि यदि आपको विशिष्ट बीजों को रखने की अनुमति दी जाती है, तो आप किसी भी PRNG के "बुरे दिखने" वाले व्यवहार को दिखा सकते हैं। अपने दावे के बावजूद कि पीसीजी किसी भी तरह से अद्वितीय है, वास्तव में पीसीजी बहुत पारंपरिक है - पीसीजी की धाराएं स्प्लिटमिक्स की तुलना में बदतर नहीं हैं, जो एक और व्यापक रूप से इस्तेमाल किया जाने वाला पीआरएनजी है।

जो पूरी तरह से झूठ है। मुझे गलत साबित करने के लिए MRG32k3a या xoshiro256 ++ से दो सहसंबद्ध नॉनवर्लेपिंग सीक्वेंस दिखाएं।

मैंने कभी भी गैर-अतिव्यापी नहीं कहा। मुझे वर्तमान में xoshiro256 ++ के लिए उपलब्ध परीक्षण दिखाएं। कि दो बीज ओवरलैप होने से बचते हैं।

इसके विपरीत, मेरे पास पीसीजी के लिए एक परीक्षण है जो दिखाता है कि आपके द्वारा दिखाए गए "सहसंबंध" मूल रूप से ओवरलैप का एक रूप हैं।

मैं FUD को "अनिवार्य रूप से" और "एक फॉर्म" की तरह नहीं लड़ सकता, लेकिन मैंने http://prng.di.unimi.it/intpcgnumpy.c को संशोधित किया ताकि शुरू में यह प्रत्येक PRNG के 10 बिलियन बार पुन: प्रसारित हो, और एक त्रुटि के साथ बाहर निकल जाए संदेश यदि उत्पन्न अनुक्रम दूसरे PRNG की प्रारंभिक स्थिति को ट्रेस करता है। यह गारंटी देता है कि प्रैक्ट्रैंड में पहले 160GB डेटा गैर-अतिव्यापी अनुक्रमों से आता है:

./intpcgnumpy 0x596d84dfefec2fc7 0x0579f81ab9f3e37b 0x8d7deae980a64ab0 0x6c79f81ab9f3e37b | stdbuf -oL ~/svn/c/xorshift/practrand/RNG_test stdin -tf 2 -te 1 -tlmaxonly -multithreaded
[...]
rng=RNG_stdin, seed=unknown
length= 64 gigabytes (2^36 bytes), time= 926 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/8]FPF-14+6/64:(0,14-0)      R=  +8.8  p =  8.7e-8   mildly suspicious
  [Low1/8]FPF-14+6/64:all           R=  +6.3  p =  2.1e-5   unusual          
  [Low1/16]FPF-14+6/64:(0,14-0)     R=  +7.6  p =  1.1e-6   unusual          
  [Low1/16]FPF-14+6/64:(1,14-0)     R=  +8.3  p =  2.9e-7   mildly suspicious
  [Low1/16]FPF-14+6/64:all          R=  +8.0  p =  5.8e-7   suspicious       
  [Low1/16]FPF-14+6/32:all          R=  +7.1  p =  3.9e-6   mildly suspicious
  [Low1/64]FPF-14+6/32:cross        R=  +7.1  p =  2.6e-6   mildly suspicious
  [Low4/32]FPF-14+6/64:(0,14-0)     R= +13.5  p =  4.3e-12   VERY SUSPICIOUS 
  [Low4/32]FPF-14+6/64:all          R=  +9.0  p =  5.9e-8   very suspicious  
  [Low4/64]FPF-14+6/64:(0,14-0)     R= +11.4  p =  3.8e-10  very suspicious  
  [Low4/64]FPF-14+6/64:all          R=  +8.0  p =  5.3e-7   suspicious       
  [Low4/64]FPF-14+6/32:(0,14-0)     R= +10.3  p =  3.6e-9   suspicious       
  [Low4/64]FPF-14+6/32:all          R=  +6.1  p =  3.2e-5   unusual          
  [Low8/64]FPF-14+6/64:(0,14-0)     R= +18.6  p =  8.4e-17    FAIL           
  [Low8/64]FPF-14+6/64:(1,14-0)     R= +11.4  p =  3.9e-10  very suspicious  
  [Low8/64]FPF-14+6/64:(2,14-0)     R=  +8.3  p =  2.8e-7   mildly suspicious
  [Low8/64]FPF-14+6/64:all          R= +15.3  p =  6.9e-14    FAIL           
  [Low8/64]FPF-14+6/32:(0,14-0)     R=  +7.8  p =  7.1e-7   unusual          
  [Low8/64]FPF-14+6/32:(1,14-0)     R=  +7.2  p =  2.7e-6   unusual          
  [Low8/64]FPF-14+6/32:all          R=  +5.8  p =  6.9e-5   unusual          
  ...and 1786 test result(s) without anomalies

इस विशेष इनिशियलाइज़ेशन डेटा में केवल 56 निचले बिट्स होते हैं, इसलिए उच्चतर बिट्स को फ़्लिप करके 2 ^ 72 सहसंबद्ध अनुक्रम उत्पन्न कर सकते हैं। सांख्यिकीय विफलताएं सिर्फ 64GB डेटा के बाद होती हैं, यह दर्शाता है कि सहसंबंध के लिए ओवरलैप जिम्मेदार नहीं हैं। यह संभव है कि अन्य विशिष्ट लक्षित विकल्पों के साथ 64 जीबी से पहले ओवरलैप होता है, निश्चित रूप से - यह एक विशिष्ट उदाहरण है। लेकिन अब यह जांचना आसान है कि ओवरलैपिंग समस्या नहीं है - जनरेटर में बहुत अधिक अवांछनीय आंतरिक सहसंबंध है।

कृपया आचार संहिता का सम्मान करें। निर्देशों के साथ अपनी टिप्पणियों को "सशक्त, स्वागत, अनुकूल और धैर्यपूर्ण" होने के लिए और "हमारे द्वारा चुने गए शब्दों में सावधान रहें। हम अपने संचार में सावधान और सम्मानजनक हैं" रखने की कोशिश करें।

मैंने कभी भी गैर-अतिव्यापी नहीं कहा। मुझे वर्तमान में xoshiro256 ++ के लिए उपलब्ध परीक्षण दिखाएं। कि दो बीज ओवरलैप होने से बचते हैं।

खैर, यह तुच्छ है: धारा की लंबाई, पुनरावृति तय करें, और जांचें कि दो धाराएं प्रारंभिक स्थिति को पार नहीं करती हैं। यह वही कोड है जो मैंने प्रोग्राम में सहसंबद्ध पीसीजी धाराओं को दिखाने के लिए इस्तेमाल किया था http://prng.di.unimi.it/intpcgnumpy.c ओवरलैप नहीं है।

अपने दावे के बावजूद कि पीसीजी किसी भी तरह से अद्वितीय है, वास्तव में पीसीजी बहुत पारंपरिक है - पीसीजी की धाराएं स्प्लिटमिक्स की तुलना में बदतर नहीं हैं, जो एक और व्यापक रूप से इस्तेमाल किया जाने वाला पीआरएनजी है।

आईएमएच, पीसीजी के भीतर आत्म-संबंध बहुत खराब है। एडिटिव जेनरेटर के लिए कोई परिणाम नहीं है, जो कि स्प्लिटमिक्स के उदाहरण है, जो कि डर्स्ट के नाटकीय 1989 के एलसीजी के बारे में परिणाम है।

लेकिन स्प्लिटमिक्स की बहुत ही मामूली समस्याएं ज्ञात हैं, और जेईपी 356 उन समस्याओं को दूर करने की कोशिश करते हुए, विभाजनकारी जनरेटर, एलएक्सएम की एक नई श्रेणी प्रदान करेगा। यह पीसीजी को स्थानांतरित करने और बदलने का समय होगा, वह भी कुछ कम खामियों के साथ।

अंतर्निहित मुद्दा दोनों जनरेटर के लिए जाना जाता है, और यह राज्य मिश्रण की कमी के कारण है। यदि आप उन जनरेटर में से किसी एक के राज्य का बिट _k_ बदलते हैं, तो परिवर्तन बिट _k_ के नीचे कभी भी प्रचारित नहीं होगा। एफसी-लीनियर जेनरेटर, सीएमडब्ल्यूसी जनरेटर आदि में प्राइम मॉडुलस के साथ एलसीजी में ऐसा नहीं होता है। अन्य सभी जेनरेटर अपने राज्य को जल्दी से जल्दी और ज्यादा से ज्यादा मिलाने की कोशिश करते हैं।

पीसीजी और स्प्लिटमिक्स की समस्याओं की समानता एक लाल हेरिंग है। स्प्लिटमिक्स में एक बहुत ही सरल अंतर्निहित जनरेटर है, बस एडिटिव, लेकिन उसके ऊपर एक स्क्रबिंग फ़ंक्शन है जो बहुत शक्तिशाली है: यह Appleby का 64-बिट मुरमुरैश 3 हैश फ़ंक्शन का अंतिम रूप है, जिसे कई संदर्भों में व्यापक रूप से उपयोग किया गया है और Stafford (http://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html) द्वारा सुधार किया गया है। फ़ंक्शन के स्थिरांक को विशिष्ट, औसत दर्जे का हिमस्खलन गुण होने के लिए प्रशिक्षित किया गया है। यहां तक ​​कि बिट की संख्या में परिवर्तन सभी आउटपुट पर फैलते हैं। दूसरे शब्दों में, स्प्लिटमिक्स दिग्गजों के कंधे पर खड़ा है।

इसके विपरीत, एलसीजी अंतर्निहित पीसीजी जनरेटर में एक ही कमी-की-मिश्रण समस्याएं होती हैं, लेकिन स्क्रैचिंग फ़ंक्शन केवल किसी भी सैद्धांतिक या सांख्यिकीय गारंटी के बिना लेखक द्वारा इकट्ठे अंकगणित और तार्किक संचालन का एक सरल अनुक्रम है। यदि वे इस तथ्य का ध्यान रखते हुए तैयार किए गए थे कि अंतर्निहित LCG के सभी अनुक्रम एक ही मोड्यूलो एक योजक स्थिरांक है और संभवतः एक संकेत परिवर्तन है, तो समस्या को संबोधित करना संभव होगा।

लेकिन लेखक को इस बात का अंदाजा नहीं था कि क्रम इतनी आसानी से एक से दूसरे के लिए निकलेगा। पीसीजी तकनीकी रिपोर्ट (https://www.pcg-random.org/pdf/hmc-cs-2014-0905.pdf) की धारा 4.2.3 में इस कथन को आसानी से देखा जा सकता है:

"संख्या के एक भिन्न अनुक्रम में _c_ के प्रत्येक विकल्प का परिणाम होता है, जिसमें क्रमिक आउटपुट के अपने जोड़े में से कोई भी अन्य अनुक्रम के साथ आम नहीं होता है।"

यह प्रमाण के रूप में लिया जाता है कि अनुक्रम अलग-अलग हैं, अर्थात अंतर्निहित LCG कई स्ट्रीम प्रदान करता है। इस विषय के बारे में डर्स्ट के 1989 के नकारात्मक परिणाम कागज में कहीं दिखाई नहीं देते हैं। जैसा कि मैंने पहले कहा था, उन परिणामों के अनुसार इस तरह के सभी अनुक्रम समान हैं, एक additive निरंतर modulo और संभवतः एक संकेत परिवर्तन (अधिकतम शक्ति के 2-मापांक के साथ LCGs के लिए, जैसा कि पीसीजी में होता है)।

मुझे यकीन है कि डर्स्ट के परिणामों को उद्धृत नहीं करना एक _bona fide_ गलती है, लेकिन समस्या यह है कि एक बार जब आप अंतर्निहित LCG के बारे में आश्वस्त हो जाते हैं, तो आप "स्ट्रीम" प्रदान करते हैं जो कुछ अर्थों में "भिन्न" होते हैं, जब वे नहीं होते हैं, तो आप ऊपर हैं। पीसीजी जैसे जनरेटर के साथ जिसमें प्रत्येक बाद के लिए 2 ^ 72 गैर-अतिव्यापी, सहसंबद्ध अनुवर्ती हैं, भले ही आप "स्ट्रीम" को बदल दें।

आपके इनपुट के लिए आप सबका धन्यवाद। फिलहाल, मैं "पीसीजी अच्छा / बुरा" जैसे द्विआधारी निर्णयों में दिलचस्पी नहीं रखता हूं। कृपया ऐसी चर्चाओं के लिए अपने स्वयं के मंचों का उपयोग करें। यहाँ ऑन-टॉपिक क्या है और कौन-सा सुस्वादु करेगा, और वह अंतिम निर्णय खसखस ​​डेवलपर्स का है। हम उस विशेषज्ञता की सराहना करते हैं जो आप सभी इस चर्चा में लाते हैं, लेकिन मैं इसे अंतिम निर्णय के बजाय अंतर्निहित तथ्यों पर केंद्रित करना चाहता हूं। मैं विशेष रूप से मात्रात्मक बयानों की सराहना करता हूं जो मुझे उस हेडरूम की मात्रा का अनुमान देते हैं जो हमारे पास है। यदि मेरे पहले के निर्णय गलत थे, तो ऐसा इसलिए था क्योंकि मैं जल्द ही निर्णय के लिए कूद गया, इसलिए मैं फिर से बचने में आपकी सहायता की सराहना करूंगा। धन्यवाद।

ध्यान दें कि 50% अधिक संभावना प्राप्त करने के लिए कि दो जनरेटर दो सहसंबद्ध बीज (यादृच्छिक पर चुने गए) से शुरू होते हैं, आपको यादृच्छिक (जन्मदिन विरोधाभास) पर शुरू होने वाले लगभग आधे मिलियन जनरेटर की आवश्यकता होती है।

@vigna क्या आप मुझे इस गणना के माध्यम से चल सकते हैं? जन्मदिन की टक्कर की गणना जो मैं परिचित हूं, वह n - 2**(n/2) टक्कर 2**19 , इसलिए आप दावा करते हैं कि खतरनाक सहसंबंध निचले बिट्स में लगभग 40-बिट टक्कर से शुरू होते हैं, लेकिन मैंने सबूत नहीं देखा है कि यह व्यावहारिक रूप से अवलोकन योग्य है। मैंने निचले 40 बिट्स को साझा करने वाले एक जोड़े का परीक्षण किया है और परीक्षण रद्द करने से पहले प्रैक्ट्रैंड में 16 टीआईबी के लिए मिला है। यदि आपने 40-बिट टक्कर के साथ विफलता देखी है, तो आपको इसे देखने के लिए कितने टीआईबी का परीक्षण करना होगा?

मुझे विश्वास है कि वेतन वृद्धि से टकराव की संभावना प्रभावित नहीं होती है। "पीसीजी धाराओं" के गुणों की आगे की चर्चा ऑफ-टॉपिक है। "लेखक" पर बार-बार हथौड़ा चलाने के बहाने के रूप में उस चर्चा का उपयोग करना हमारे

@imneme यह करने के लिए संबंधित प्रतीत होती है कूद के साथ मुद्दों 2. की एक बड़ी शक्ति की एक बहु से जब मैं की एक जोड़ी का निर्माण PCG64 एक ही वेतन वृद्धि और साझा करने के कम से उदाहरणों n बिट्स, जो दूरी मैं दोनों के बीच की गणना करता हूं वह 1 << n की एक बहु है। ऐसा प्रतीत होता है कि आपका मजबूत DXSM आउटपुट फ़ंक्शन इस अभिव्यक्ति को भी हल करने के लिए प्रकट होता है। मैंने PCG64DXSM उदाहरणों की एक जोड़ी का परीक्षण किया है जो एक वृद्धि को साझा करते हैं और 64-बिट्स राज्य को बिना किसी समस्या के 2 TiB तक बढ़ाते हैं।

ठीक है, यह शर्मनाक है: यह आधा _billion_ था, आधा _million_ नहीं। एक अकेला अक्षर बड़ा बदलाव ला सकता है। मैं पर्ची के लिए माफी मांगता हूं।

लेकिन, जैसा कि मैंने जल्दी कहा, यह ठीक वैसी ही प्रारंभिक अवस्था से टकराने की संभावना है, सहसंबद्ध अनुवर्ती के एक महत्वपूर्ण ओवरलैप की संभावना नहीं। व्यक्तिगत रूप से मैं सहसंबद्ध अनुवर्ती के बिना PRNG का उपयोग करना पसंद करता हूं, क्योंकि उनमें से बहुत सारे हैं, लेकिन, जैसा कि आप सही कहते हैं, निर्णय केवल आपका है।

स्क्रैचिंग फंक्शन को ठीक करना ताकि इसमें बेहतर मिक्सिंग प्रॉपर्टीज हों जो पूरी तरह से उचित समाधान की तरह लगें।

मेरा पोस्ट सिर्फ पीसीजी और स्प्लिटमिक्स के बीच संरचनात्मक अंतर का स्पष्टीकरण था, क्योंकि पिछले पोस्ट में दावा किया गया था कि उन्हें इसी तरह की समस्याएं थीं, और मुझे नहीं लगता कि यह एक सही कथन है। आप SplitMix के लिए http://prng.di.unimi.it/corrpcgnumpy.c जैसे प्रोग्राम नहीं लिख सकते।

@ क्रेंक , आपने पूछा:

@imneme यह करने के लिए संबंधित प्रतीत होती है कूद के साथ मुद्दों 2. की एक बड़ी शक्ति की एक बहु से जब मैं की एक जोड़ी का निर्माण PCG64 एक ही वेतन वृद्धि और साझा करने के कम से उदाहरणों n बिट्स, दोनों के बीच की दूरी मैं 1 << n की एक बहु है। ऐसा प्रतीत होता है कि आपका मजबूत DXSM आउटपुट फ़ंक्शन इस अभिव्यक्ति को भी हल करने के लिए प्रकट होता है। मैंने PCG64DXSM उदाहरणों की एक जोड़ी का परीक्षण किया है जो बिना वेतन वृद्धि और 64-बिट्स के राज्य को बिना किसी समस्या के 2 TiB तक साझा करता है।

पिछले साल से चर्चा के धागे को खोजने और जोड़ने के लिए धन्यवाद। हां, जैसा कि सेबेस्टियानो ने अपनी प्रतिक्रिया में कहा,

स्क्रैचिंग फंक्शन को ठीक करना ताकि इसमें बेहतर मिक्सिंग प्रॉपर्टीज हों जो पूरी तरह से उचित समाधान की तरह लगें।

XSL-RR चीजों के कमजोर अंत में है। इसके विपरीत, पीसीजी पेपर से दोनों मूल आरएक्सएस-एम आउटपुट फ़ंक्शन, और नए डीएक्सएसएम आउटपुट फ़ंक्शन स्क्रैचिंग के तरीके से अधिक करते हैं, और इसलिए इस प्रकार के मुद्दों को नहीं दिखाते हैं। DXSM (पिछले साल इस कमिट में PCG स्रोत में जोड़ा गया था) को विशेष रूप से XSL-RR से अधिक मजबूत बनाया गया था लेकिन समान समय प्रदर्शन (cf, RXS-M, जो धीमा है) है। मैंने पिछले साल डीएक्सएसएम का काफी कठिन परीक्षण किया था, लेकिन 67 दिनों के रन में हमें एक विस्तारित पावर आउटेज मिला, जिसने सर्वर (यूपीएस बैटरी को सूखा) लिया और परीक्षण रन को समाप्त कर दिया, लेकिन उस समय यह दोनों सामान्य रूप से बहुत अच्छा साबित हुआ था परीक्षण (128 टीबी आउटपुट का परीक्षण किया गया) और 2 ^ 48 की कूद (64 टीबी आउटपुट का परीक्षण किया गया, क्योंकि यह धीमी गति से चलता है)।

अगर, बिना डीएक्सएसएम डिजाइन किए भी, आरएक्सएस-एम ने इस मुद्दे का ध्यान रखा होगा, तो एक सवाल यह है कि मैंने कभी इसके बजाय कमजोर एक्सएसएलआर-आरआर क्रमचय का उपयोग क्यों किया है - हमेशा आउटपुट फ़ंक्शन में बहुत मजबूत बिट-स्क्रैच का उपयोग क्यों नहीं किया जाता है? इसका उत्तर यह है कि यह मूल रूप से साइकिल से आता है। लोगों के लिए गति मायने रखती है, इसलिए आप अपनी आवश्यकता से बहुत अधिक हाथापाई करने से बचने की कोशिश करते हैं।

यह एक ऐसा मुद्दा है जो सेबेस्टियानो से परिचित है, क्योंकि उनका दृष्टिकोण और मेरा बहुत आम है। हम प्रत्येक एक लंबे स्थापित दृष्टिकोण को लेते हैं जो आधुनिक सांख्यिकीय परीक्षणों (मेरे मामले में LCGs, और मार्साग्लिया के XorShift LFSRs) में विफल हो जाएगा और इसे भुनाने के लिए एक स्क्रबिंग आउटपुट फ़ंक्शन जोड़ें। हम दोनों उस आउटपुट फंक्शन को सस्ता बनाने का प्रयास करते हैं, और हम दोनों को थोड़ा-बहुत बाहर निकाल दिया गया है, जहां अंतर्निहित जनरेटर में कमियां हैं जो हम अपने आउटपुट फ़ंक्शन के साथ मुखौटा बनाने की कोशिश कर रहे हैं। उनके मामले में, यह रैखिकता के मुद्दे हैं, जिनके माध्यम से दिखाया गया है ।

लेकिन कुछ हद तक हाल के कामों ने मुझे बहुत प्रसन्न किया, उन्होंने यह भी दिखाया कि एलएफएसआर-आधारित डिज़ाइनों में हैमिंग-वेट इश्यूज़ (खुद की एक लंबी चिंता को दर्शाते हुए) हैं जो कि उनके आउटपुट फंक्शन्स द्वारा अपर्याप्त हैं। उनके स्वयं के जनरेटर उनके परीक्षण को पास करते हैं, इसलिए यह कुछ है, लेकिन 2018 में वापस जब मैं उनके नए xoshiro PRNG को देख रहा था , तो यह मुझे लग रहा था कि अंडरलाइन जनरेटर से हैमिंग-वेट मुद्दों ने अपने आउटपुट फ़ंक्शन के माध्यम से इसे बनाया। चूंकि वह एक नए आउटपुट फ़ंक्शन के साथ xoshiro को संशोधित कर रहा है, और मुझे उम्मीद है कि चाल (उसने कुछ अन्य बदलाव भी किए हैं, इसलिए शायद यह भी दोहराता है कि इस परीक्षण कार्यक्रम द्वारा हाइलाइट किए गए मुद्दे को ठीक करता है?)।

जैसा कि उनके सहसंबंध कार्यक्रमों के लिए, 2018 में जब उन्होंने अपनी वेबसाइट पर पीसीजी की आलोचना की, जिसमें वे विभिन्न मुद्दों (जैसे वंचित बीजारोपण, आदि) के साथ लिखे गए कार्यक्रम शामिल थे, मैंने एक प्रतिक्रिया लिखी जिसमें समान कार्यक्रमों का एक समूह था। अन्य लंबे समय से स्थापित PRNGs के लिए, जिसमें corrsplitmix2.c जो स्प्लिटमिक्स में सहसंबद्ध स्ट्रीम बनाता है। मुझे पूरा यकीन नहीं है कि सेबस्टियन का क्या मतलब है जब उसका कहना है कि यह नहीं किया जा सकता है, लेकिन मैं स्वीकार करूंगा कि मुझे उसके परीक्षण कार्यक्रम को करीब से देखने का मौका नहीं मिला है कि क्या उसका नया व्यक्ति उससे अलग है? कुछ साल पहले लिखा था।

कृपया मेरी समझ की कमी को क्षमा करें - लेकिन क्या मैं किसी से इस स्तर पर निष्कर्ष निकालने के लिए कह सकता हूं? क्या वास्तविक परिस्थितियों में डिफ़ॉल्ट पीसीजी असुरक्षित है? डिफ़ॉल्ट स्विच करने के लिए क्या तर्क हैं?

आसान रास्ता उच्च (अल्ट्रा-हाई?) -डिमेंशनल एप्लिकेशन और सहसंबद्ध अनुक्रम की संभावना के बारे में कुछ प्रलेखन जोड़ना है।

एक कठिन रास्ता आउटपुट फ़ंक्शन को बदलने के लिए होगा जो स्ट्रीम को तोड़ देगा। मुझे यकीन नहीं है कि एक वादा default_rng कितना मजबूत है। डॉक्स ने चेतावनी नहीं दी है कि यह बदल सकता है इसलिए इसे बदलने के लिए संभवतः एक अपचयन चक्र की आवश्यकता होगी। इसके लिए नए आउटपुट फ़ंक्शन में एक स्टैंडअलोन बिट जनरेटर (या पीसीजी 64 से कॉन्फ़िगर करने योग्य, जो अधिक समझदार होगा) के रूप में जोड़ने की आवश्यकता होगी और फिर उपयोगकर्ताओं को चेतावनी दी जाएगी कि यह वर्ष के बाद बदल जाएगा XXXX / Y.ZZ जारी।

सबसे कठिन रास्ता एक नया डिफ़ॉल्ट रींग खोजना होगा। यह पहली बार आसान नहीं था और मुझे नहीं लगता कि पिछले 18 महीनों में सुई को किसी विशेष दिशा में स्थानांतरित करने के लिए कुछ भी बदल गया है।

मैंने default_rng() संशोधन के बारे में gh-16493 खोला, मुझे नहीं लगता कि यह इस मुद्दे से संबंधित है, यह सुनिश्चित करने के लिए भी नहीं कि हमें इस पर चर्चा करनी है, हमने शायद बहुत पहले ही नियमों को निर्धारित कर दिया था और मैं सिर्फ डॉन ' याद नहीं है।

मैं इस चर्चा को पूरी तरह से समझने का दावा नहीं करता, लेकिन ऐसा लगता है कि यह पता लगाने के लिए दो चीजें हैं:

1. यह सुनिश्चित करने के लिए कि हमारे पास पर्याप्त हेडवे है, मुझे इस पर रॉबर्ट पर भरोसा करना होगा और अभी यह मुझे लगता है कि यह हमारे ज्ञान के सर्वश्रेष्ठ के लिए ठीक होना चाहिए? (यानी एक वास्तविक टकराव की संभावना शायद शर्मनाक रूप से कम है यहां तक ​​कि वातावरण परिमाण में भी कुछ भी बड़ा नहीं है जिसका उपयोग NumPy में किया जा सकता है? भविष्य में डिफ़ॉल्ट को बदलने का वारंट हो सकता है या नहीं यह अलग मुद्दा है।)

2. हम बताते हैं:

   और समर्थन करता है [...] साथ ही: गणित: 2^{127} स्ट्रीम

   जो, यह नहीं जानते कि नंबर कहां से आता है, ऐसा लगता है कि यह हमारी ओर से थोड़ा ओवरस्टेट हो सकता है और हम इसे पूरी तरह से सही होने के लिए थोड़ा समायोजित कर सकते हैं? या अतिरिक्त विवरण देने वाले कुछ बाहरी संसाधनों से लिंक करें?

अभी करने के लिए सबसे आसान काम एक PCG64DXSM BitGenerator जोड़ना होगा, "सस्ते गुणक" के साथ PCG64 का संस्करण और DXSM आउटपुट फ़ंक्शन। मुझे लगता है कि हर कोई इस बात से सहमत है कि XSL-RR आउटपुट फ़ंक्शन से एक कदम ऊपर है जो अब हमारे PCG64 कार्यान्वयन में है, रनटाइम प्रदर्शन को नुकसान के बिना बेहतर सांख्यिकीय रूप से प्रदर्शन कर रहा है। यह आला में एक सीधा उन्नयन है जो PCG64 BitGenerator s के लिए कार्य करता है जो हम प्रदान करते हैं। मुझे लगता है कि हमें इसे PCG64 साथ जोड़ना चाहिए।

संयोग से, मैं पसंद है कि यह हो सकता है एक अलग नाम दिया BitGenerator के लिए एक विकल्प के बजाय PCG64 निर्माता। इस तरह के विकल्प randomgen में महान हैं, जिसका उद्देश्य बहुत सारे अलग-अलग एल्गोरिदम और वेरिएंट प्रदान करना है, लेकिन numpy , मुझे लगता है कि हम चाहते हैं कि हमारे चयन "ग्रैब-एंड-गो" हों। जितना हम कर सकते हैं।

मुझे नहीं लगता कि हमने वास्तव में default_rng() प्रदान करने वाले परिवर्तनों में बदलाव करने के लिए नीति का निपटान किया। जब मैंने इसे प्रस्तावित किया, तो मैंने यह धारणा बनाई कि जिन कारणों से मैंने इसे Generator() कंस्ट्रक्टर में अपनी कार्यक्षमता डालने के लिए पसंद किया था उनमें से एक यह था कि हम जरूरत पड़ने पर अलग-अलग नाम से कार्य कर सकें। हालाँकि, उस समय हम विचार कर रहे थे कि default_rng() को अंतर्निहित BitGenerator बहुत सारे विवरणों को उजागर करने की आवश्यकता हो सकती है, जिसे हमने बाद में टाला। क्योंकि PCG64DXSM समान API ( .jumped() विशेष रूप से) को PCG64 रूप में उजागर करता है, हमारा एकमात्र विचार यह है कि नए डिफ़ॉल्ट के रूप में उपयोग करने से बिटस्ट्रीम बदल जाएगा। मुझे लगता है कि हमारे लिए उचित होगा कि हम उसी समय का पालन करें, जो धारा Generator NEP 19 (यानी X.Y.0 फ़ीचर रिलीज़ पर) से आने वाली धारा में किसी अन्य संशोधन के रूप में हो। यदि हम चाहें तो हम थोड़ा और सतर्क हो सकते हैं, और पहले PCG64DXSM BitGenerator 1.20.0 warn() , (बिना किसी प्रभाव के शोर) कि default_rng() 1.21.0 में इसका उपयोग करने के लिए बदल जाएगा।

नए बीजी को जोड़ने के भाग के रूप में, एक गाइड के रूप में सेवा शुरू करने और नए संस्करण को प्राथमिकता देने के लिए एक औचित्य प्रदान करने के लिए पीसीजी 64 पर नोटों को अपडेट करना अच्छा होगा।

1. यह सुनिश्चित करने के लिए कि हमारे पास पर्याप्त हेडवे है, मुझे इस पर रॉबर्ट पर भरोसा करना होगा और अभी यह मुझे लगता है कि यह हमारे ज्ञान के सर्वश्रेष्ठ के लिए ठीक होना चाहिए? (यानी एक वास्तविक टकराव की संभावना शायद शर्मनाक रूप से कम है यहां तक ​​कि वातावरण परिमाण में भी कुछ भी बड़ा नहीं है जिसका उपयोग NumPy में किया जा सकता है? भविष्य में डिफ़ॉल्ट को बदलने का वारंट हो सकता है या नहीं यह अलग मुद्दा है।)

यह शायद थोड़ा बहुत glib है। यह इस बात पर निर्भर करता है कि आप प्रत्येक स्ट्रीम से कितने स्ट्रीम, कितना डेटा खींचते हैं और जन्मदिन की टक्कर के लिए आपका जोखिम क्या है। मैं उस गणित को समझने के लिए अभी तक आसानी से अनुसरण करने वाली सिफारिशों को समझने के लिए एक संक्षिप्त पैराग्राफ में नहीं जुटा पाया, यही कारण है कि मैंने कुछ समय में इस गितूब मुद्दे पर दोबारा गौर नहीं किया। मुझे नहीं लगता कि यह एक बाल-ऑन-फायर मुद्दा है जिसे अभी _ _ ठीक करने की आवश्यकता है, हालांकि।

मैं बाद में कुछ लिखूंगा, लेकिन जैसा कि मैंने इस थ्रेड में देखा है कि हम पिछले साल के मुकाबले ग्राउंड को पीछे छोड़ रहे हैं। सेबेस्टियानो के अलावा कुछ भी नहीं बदला है कि न्यूमी ने पीसीजी को भेज दिया था। पिछले साल NumPy टीम से विश्लेषण अधिक गहराई में था, और अधिक प्रशंसनीय परिदृश्यों पर विचार किया गया था।

मेरी प्राथमिकता डिफ़ॉल्ट रूप से यथासंभव शीघ्रता से उन्नयन करना होगा - सिर्फ भ्रम को कम करने के लिए। मेरा मतलब है, एक चक्रण चक्र की प्रतीक्षा न करें।

@imneme - बहुत बहुत धन्यवाद - मुझे एक लंबी बात बहुत उपयोगी

शायद पिछले पोस्ट विस्फोट इसके बारे में है। मुझे लगता है कि यह निश्चित रूप से पढ़ने लायक है। आप हमें इन मुद्दों के बारे में बात करते देखने के लिए वहां से थ्रेड में वापस स्क्रॉल कर सकते हैं। यह पीसीजी 32 के बारे में था।

मेरे दिमाग में था कि मैं क्या कहना चाहता हूं, लेकिन मुझे लगता है कि मैं एक साल पहले के पदों को देख रहा हूं, मैंने यह सब पहले से ही कहा है, यहां और कहीं और ( मेरा ब्लॉग (2017), reddit , मेरा ब्लॉग फिर से (2018) , और NumPy चर्चाओं आदि में)

धाराओं और उनकी आत्म-समानता के बारे में (जिसके लिए @rkern ने एक स्ट्रीम-निर्भरता परीक्षक लिखा), मैंने पिछले साल लिखा था:

जैसा कि मेरे ब्लॉग पोस्ट में पहले उल्लेख किया गया था, स्प्लिटमिक्स के साथ पीसीजी की धाराओं में बहुत कुछ है।

_Mveryinson के ग्राफ के बारे में, _every_ PRNG के लिए, जो आपको काउंटर-आधारित क्रिप्टोग्राफिक वाले सहित पूरे राज्य को बीज बनाने की अनुमति देता है, हम ऐसे बीजारोपण कर सकते हैं जहां हमारे पास PRNG होंगे जिनके आउटपुट किसी तरह से सहसंबद्ध थे (ऐसा करने का सबसे आसान तरीका PRNG राज्यों को बनाने के लिए है जो थोड़ी दूरी पर हैं, लेकिन अक्सर हम यह समझने के आधार पर अन्य काम कर सकते हैं कि वे कैसे काम करते हैं)। और यद्यपि PRNGs जो पूर्ण-राज्य सीडिंग की अनुमति नहीं देते हैं, इस समस्या से बच सकते हैं, ऐसा करने से केवल एक नया परिचय मिलता है, केवल अपने संभावित राज्यों के एक छोटे से हिस्से तक व्यावहारिक पहुंच प्रदान करता है।

धाराओं के बारे में सोचने का सही तरीका बस अधिक यादृच्छिक स्थिति है जिसे बीजने की आवश्यकता है। 1,2,3 जैसे छोटे मूल्यों का उपयोग करना आमतौर पर _any_ PRNG के लिए किसी भी बीजारोपण के उद्देश्यों के लिए बुरा विचार है (क्योंकि यदि हर कोई इन बीजों का पक्ष लेता है, तो उनके संबंधित प्रारंभिक क्रम को ओवररप्रिटेड किया जाएगा)।

हम इसे एक धारा नहीं कह सकते हैं और इसे केवल राज्य कह सकते हैं। यही मंगलगेलिया ने counter शेष राज्य के साथ बिल्कुल भी बातचीत नहीं करता है, और, एलसीजी की तरह, और प्रारंभिक मूल्य में भिन्नताएं वास्तव में केवल एक जोड़ा स्थिरांक में राशि होती हैं।

स्प्लिटमिक्स, PCG और XorWow की धाराएँ हैं जिन्हें हम "स्टूपिड" स्ट्रीम कह सकते हैं। वे जनरेटर के एक तुच्छ पुनर्मूल्यांकन का गठन करते हैं। हालांकि इसमें मूल्य है। मान लीजिए कि धाराओं के बिना, हमारे PRNG में 42 की एक दिलचस्प करीबी पुनरावृत्ति होगी, जहां त्वरित उत्तराधिकार में 42 बार कई फसलें होती हैं और यह केवल 42 के लिए होता है और कोई अन्य संख्या नहीं है। बेवकूफ "बस एक वेतन वृद्धि" या "सिर्फ एक एक्सोर" धाराओं के साथ, हम वास्तव में 42 तक अजीब दोहराने से बचने से बचेंगे; सभी नंबरों में एक स्ट्रीम होती है जिसमें वे अजीब तरह से दोहराते हैं। (इस कारण से, मैं जोशीरो 256 में क्लोज-रिपीट की समस्याओं को ठीक करने के लिए लागू होता है, एक

(मैं तब इस टिप्पणी और इस एक में और अधिक गहराई में चला गया।)

मैं कहता हूं कि मुख्य टेक-ऑफ यह है कि लगभग _any_ PRNG के लिए, थोड़े समय और ऊर्जा के साथ आप पैथोलॉजिकल सीडिंग्स को नियंत्रित कर सकते हैं। PCG कुछ असामान्य स्थिति में है कि इसमें कोई ऐसा व्यक्ति है जो PCG के लिए विशेष रूप से प्रशंसनीय बीजारोपण का काम करता है, जिसमें हाथ से तैयार की गई पैथोलॉजी (यानी, सेबस्टियानो) है। उस काम के परिणामस्वरूप, मैंने अपने PRNGs और अन्य लंबे समय तक रहने वाले लोगों के लिए चारों ओर घूम लिया है।

सामान्य तौर पर, आप PRNG स्थिति को "थोड़े यादृच्छिक" लगने वाली चीज़ के साथ आरंभ करना चाहते हैं। यह बहुत सार्वभौमिक है, भले ही लोग अन्यथा करना चाहें । उदाहरण के लिए, किसी भी LFSR PRNG (XorShift-style, Mersenne Twister, आदि) के लिए, आपको इसे एक ऑल-जीरो स्टेट के साथ इनिशियलाइज़ नहीं करना चाहिए क्योंकि यह सिर्फ वहीं अटका रहेगा। लेकिन यहां तक ​​कि कहा गया है कि ज्यादातर-शून्य एलएफएसआर के लिए अक्सर समस्याग्रस्त होते हैं (एक घटना जिसे ज़ेरोलैंड के रूप में जाना जाता है, और क्यों सी ++ लोगों ने seed_seq ।)। यदि आप "कुछ कंट्रीब्यूटेड सीडिंग करते हैं" गेम खेलना चाहते हैं, तो 100 LFSR के लिए इनिशियलाइज़ेशन का संग्रह बनाना मुश्किल नहीं है और उन सभी को ज़ीरो-लैंड मार से 1K दूर होना चाहिए। वंचित शुरुआती सभी पर्याप्त निर्दोष दिखेंगे, लेकिन वे सभी एक ही समय में वजन कम करने में इस अजीब गिरावट को मार देंगे।

यदि आप एक PCG जनरेटर का उपयोग कर रहे हैं जो कि उचित एन्ट्रापी के साथ आरंभ किया गया था, तो यह ठीक है। यदि आप इसे 1, 2, 3 जैसे कबाड़ से शुरू करना चाहते हैं, तो यह वास्तव में किसी भी PRNG के साथ समस्याग्रस्त है । और पीसीजी के साथ, 99.9% समय, यहां तक ​​कि थोड़े कबाड़ का उपयोग करना भी ठीक होगा। यह LFSR के मुद्दों की तरह कुछ भी नहीं है।

लेकिन DXSM निश्चित रूप से मजबूत है। मुझे लगता है कि यह बेहतर है या मैंने इसे नहीं बनाया है, लेकिन यह कुछ परिप्रेक्ष्य और यह महसूस करने के लायक है कि व्यवहार में उपयोगकर्ता क्लासिक PCG64 कार्यान्वयन के साथ समस्याओं में नहीं जा रहे हैं।

मैं वर्तमान चर्चा से PCG64 की धाराओं (LCG वृद्धि के माध्यम से) की आलोचना / बचाव को अलग करना चाहूंगा। जबकि LCG के गणित के कारण एक निश्चित द्वंद्व शामिल है, यह मूल मुद्दा नहीं है जो मूल रूप से यहां लाया गया था। इसके अलावा, सेबास्टियानो के मूल समालोचना , आपकी प्रतिक्रिया या पुराने मेगा-थ्रेड में मौजूद होने की तुलना में यहां अधिक विवरण दिया गया है। शायद उन विशेषज्ञों के लिए कनेक्शन अधिक स्पष्ट है जिन्होंने गणित पर अधिक समय बिताया है, लेकिन व्यावहारिक परिणाम अब मेरे लिए स्पष्ट हैं, कम से कम।

मैं कहता हूं कि मुख्य टेक-ऑफ यह है कि लगभग _any_ PRNG के लिए, थोड़े समय और ऊर्जा के साथ आप पैथोलॉजिकल सीडिंग्स को नियंत्रित कर सकते हैं।

दी गई है, लेकिन यह मेरे सामने निर्णय को ड्राइव नहीं कर सकता / सकती है। अगर मैं एक परिमित PRNG से बहुत अधिक संख्याएँ खींचता हूँ, तो अंततः प्रैक्ट्रेंड इसे बाहर कर देगा। यह द्विआधारी तथ्य उस PRNG एल्गोरिथ्म को अमान्य नहीं करता है। उस बाइनरी से दूर जाना और हेडरूम की अवधारणा को स्थापित करना उन चीजों में से एक था जिसे मैंने वास्तव में मूल पीसीजी पेपर के बारे में सराहा था। प्रतिकूल रूप से उत्पन्न पैथोलॉजी को देखते हुए, हम इस बात पर एक नज़र डाल सकते हैं कि पैथोलॉजी कितनी अच्छी तरह से अच्छी एन्ट्रापी-सीडिंग से उत्पन्न हो सकती है। मैं चाहता हूं कि इसकी मात्रा तय करें, और इसे उपयोगकर्ताओं के लिए व्यावहारिक सलाह में बदल दें।

उन दो राज्यों को देखते हुए जो निचले 58 बिट्स और एक ही वेतन वृद्धि (हम उस में एक पिन डालेंगे) को साझा करते हैं, उन राज्यों से PCG64 XSL-RR उदाहरणों को इंटरएक्टिव करते हुए लगभग 32 GiB पर प्रैक्ट्रैंड में व्यावहारिक रूप से अवलोकनीय विफलताओं को प्रदर्शित करता है। मुझे लगता है कि इससे बचना उचित है। तो चलिए इसे अपने बेंचमार्क के रूप में लेते हैं और देखते हैं कि कितनी बार अच्छी एन्ट्रापी-सीडिंग होती है। सौभाग्य से, यह प्रतिकूल योजना संभाव्य विश्लेषण के लिए उत्तरदायी है (सभी इतने अनुकूल नहीं हैं)। n इंस्टेंस के लिए, किसी भी 2 की समान 58 बिट्स साझा करने की संभावना n**2 / 2**58 , डबल-काउंटिंग के लिए 2 का कारक दें या लें। इसलिए आधे बिलियन उदाहरणों में, अच्छा है कि एक ऐसी जोड़ी है जो अगर Intereaeaved प्रेक्टैंड को विफल कर देगी। आधा बिलियन बहुत है! मेरे फैसले में, हम शायद कभी भी numpy प्रोग्राम नहीं देखेंगे जो कि कई PCG64 इंस्टेंस बनाने की कोशिश करता है। numpy संभवतः गलत टूल होगा।

मुझे लगता है कि आरंभिक राज्यों से बचना चाहते हैं, जिनका बाद का ड्रा _cross_ किसी भी अन्य प्रारंभिक राज्यों के निचले -58-बिट-टकराव वाले राज्यों में से एक है। मैं अभी भी उस पर तर्क के माध्यम से सोचने की कोशिश कर रहा हूं, लेकिन मुझे लगता है कि लंबाई द्विघात के बजाय संभावना को रैखिक रूप से प्रभावित करती है। अगर मैं सही हूं, और मैं प्रत्येक उदाहरण ( 2**28 ड्रॉ) से 16 GiB आकर्षित करना चाहता हूं, जो कि हमने प्रैक्टिरैंड विफलताओं को दर्शाने वाले प्रत्येक जोड़े से कितना लिया है, तो मैं केवल 2**15 साथ काम कर सकता हूं numpy प्रोग्राम XSL-RR आउटपुट फ़ंक्शन के साथ PCG64 का उपयोग करके समस्याओं में चलने की संभावना है। लेकिन कुछ एप्लिकेशन बंद होने लग सकते हैं (उदाहरण के लिए बड़े वितरित सुदृढीकरण सीखने के रन)।

चलो उस वेतन वृद्धि को बाहर ले जाओ और इसे संबोधित करें। मुझे लगता है कि यह कहना उचित है कि एक्सएसएलआर-आरआर आउटपुट फ़ंक्शन के साथ, राज्य के अतिरिक्त एन्ट्रापी-बीजिंग भी इस विशेष विश्लेषण को नहीं बदलता है। ऐसा लगता है कि एन्ट्रापी-सीडेड इन्क्रीमेंट की किसी भी जोड़ी के लिए, व्यावहारिक रूप से टकराने वाले राज्यों की समान संख्या है। जानबूझकर उन राज्यों के निर्माण के लिए ठोस प्रक्रिया समान निचले 58 बिट्स में कोसने की तुलना में अधिक जटिल लगती है, लेकिन ऐसा लगता है कि टकराने वाले राज्यों की संख्या समान है, इसलिए संभावना गणना समान रहती है। यह सामान्य रूप से पीसीजी योजना के लिए आंतरिक नहीं है। डीएक्सएसएम आउटपुट फ़ंक्शन पर्याप्त मजबूत प्रतीत होता है कि वेतन वृद्धि (यहां तक ​​कि एक साधारण +2 ) अंतर्निहित LCG के लिए सबसे खराब स्थिति का प्रतिरोध करने के लिए भी पर्याप्त प्रतीत होता है (जब दूरी मीट्रिक 0 देता है।

मैं यह दोहराकर समाप्त करना चाहता हूं कि हम सभी के बारे में क्या सही समझौता करते हैं: PCG64DXSM एक अच्छा विचार है। यदि और कुछ नहीं, तो इसके बेहतर सांख्यिकीय गुण मानसिक मॉडल को सरल बनाते हैं जिन्हें मैं दस्तावेज़ के लिए मजबूर महसूस करता हूं, और कुछ भी जिसका मतलब है कि मुझे कम दस्तावेज लिखना होगा, मेरी पुस्तक में अच्छा है।

धाराएँ अभी भी कुछ हद तक प्रासंगिक हैं क्योंकि समस्या केवल तभी दिखाई देती है जब हमारे पास उसी स्ट्रीम पर जनरेटर हों।

लेकिन किस परिस्थिति में उनके पास 58 बिट्स समान होंगे और एक ही स्ट्रीम पर होंगे? क्या कोई उपयोग मामला है जहां ऐसा होगा?

एक ऐसा कुछ यथार्थवादी मामला जो मुझे पता है कि हम पिछले साल (जब हमने jumped बारे में बात की थी), और मैंने इस पोस्ट के बारे में बात की थी जिसे मैंने पहले से जोड़ा था।

धाराएँ अभी भी कुछ हद तक प्रासंगिक हैं क्योंकि समस्या केवल तभी दिखाई देती है जब हमारे पास उसी स्ट्रीम पर जनरेटर हों।

दुर्भाग्य से, XSL-RR के लिए ऐसा नहीं है। आइए दो PCG64 XSL-RR उदाहरणों पर विचार करें। हम मनमाने ढंग से और राज्यों में से एक के रूप में एंट्रोपी-बीज को एन्ट्रापी-सीड करते हैं। हम अन्य PCG64 उदाहरण के लिए 2**70 बुरे राज्यों का निर्माण कर सकते हैं जो प्रैक्ट्रैंड को उसी तरह से विफल करते हैं जैसे कि समान-निचले -58-बिट्स-राज्य समान-वृद्धि विफलता। यह समान वेतन वृद्धि के मामले में करने के लिए बस अधिक जटिल है। अलग-अलग वेतन वृद्धि के साथ पहले राज्य के रूप में निचले 58-बिट्स को साझा करने के बजाय, यह राज्य के निचले 58-बिट्स को साझा करता है, जो कि पहली दूरी से (आपके LCG दूरी के उपाय के अनुसार) है, वेतन वृद्धि के लिए लेखांकन। मेरे पास एक रचनात्मक प्रमाण (पायथन कोड) है, लेकिन मुझे अभी बिस्तर पर जाना है और कल इसे साफ करना है।

@rkern , अच्छी बात है। मैं मानता हूँ, मैंने उस परिदृश्य का परीक्षण नहीं किया है कि यह कैसे दिखता है।

मैं कहता हूं कि मुख्य टेक-ऑफ यह है कि लगभग _any_ PRNG के लिए, थोड़े समय और ऊर्जा के साथ आप पैथोलॉजिकल सीडिंग्स को नियंत्रित कर सकते हैं। PCG कुछ असामान्य स्थिति में है कि इसमें कोई ऐसा व्यक्ति है जो PCG के लिए विशेष रूप से प्रशंसनीय बीजारोपण का काम करता है, जिसमें हाथ से तैयार की गई पैथोलॉजी (यानी, सेबस्टियानो) है। उस काम के परिणामस्वरूप, मैंने अपने PRNGs और अन्य लंबे समय तक रहने वाले लोगों के लिए चारों ओर घूम लिया है।

जैसा कि मैंने पहले ही टिप्पणी की है, यह गलत है। मुझे पता है कि सहसंबद्ध, गैर-अतिव्यापी अनुक्रमों की एक जोड़ी का कोई उदाहरण नहीं है, कहते हैं, xoshiro256 ++ से जैसा कि आप पीसीजी के भीतर आसानी से पा सकते हैं।

PRNG जो जल्दी से अपने पूरे राज्य को मिलाते हैं उन्हें यह समस्या नहीं है। यदि आप xoshiro256 ++ से दो गैर-अतिव्यापी अनुक्रम उत्पन्न करने वाला एक कार्यक्रम प्रदान कर सकते हैं, जो कि सहसंबद्ध हैं, तो जैसे उदाहरण मैंने यहां पोस्ट किए हैं, कृपया ऐसा करें।

जैसा कि उनके सहसंबंध कार्यक्रमों के लिए, 2018 में जब उन्होंने अपनी वेबसाइट पर पीसीजी की आलोचना की, जिसमें वे विभिन्न मुद्दों (जैसे वंचित बीजारोपण, आदि) के साथ लिखे गए कार्यक्रम शामिल थे, मैंने एक प्रतिक्रिया लिखी जिसमें समान कार्यक्रमों का एक समूह था। अन्य लंबे समय से स्थापित PRNGs के लिए, जिसमें corrsplitmix2.c जो स्प्लिटमिक्स में सहसंबद्ध स्ट्रीम बनाता है। मुझे पूरा यकीन नहीं है कि सेबस्टियन का क्या मतलब है जब उसका कहना है कि यह नहीं किया जा सकता है, लेकिन मैं स्वीकार करूंगा कि मुझे उसके परीक्षण कार्यक्रम को करीब से देखने का मौका नहीं मिला है कि क्या उसका नया व्यक्ति उससे अलग है? कुछ साल पहले लिखा था।

ऊपर दिए गए कार्यक्रम ने _chooses_ स्ट्रीम को_है। इसे लिखना स्पष्ट रूप से आसान है।

लेकिन इसका पीसीजी की समस्याओं से कोई लेना-देना नहीं है। मैंने जो कार्यक्रम प्रदान किया है वह _user_ स्ट्रीम चुनें, और फिर सहसंबंध दिखाता है।

मैं स्प्लिटमिक्स के लिए एक कार्यक्रम प्रदान करने के लिए फिर से http: / जैसे अन्य जनरेटर में एक सहसंबद्ध अनुक्रम पाता है,

उपयोगकर्ता को स्ट्रीम चुनने में मनमाने ढंग से सहसंबंध का अधिक मजबूत रूप दिखाता है।

जैसा कि मैंने पहले ही टिप्पणी की है, यह गलत है। मुझे पता है कि सहसंबद्ध, गैर-अतिव्यापी अनुक्रमों की एक जोड़ी का कोई उदाहरण नहीं है, कहते हैं, xoshiro256 ++ से जैसा कि आप पीसीजी के भीतर आसानी से पा सकते हैं।

ऐसा लगता है जैसे हम यहां एक-दूसरे से बात कर रहे हैं। मैंने नहीं कहा कि मैं किसी भी PRNG के लिए सहसंबद्ध, गैर-अतिव्यापी दृश्यों के साथ आ सकता हूं, मैंने कहा कि मैं सामान्य रूप से पैथोलॉजिकल सीडिंग के साथ आ सकता हूं, जैसा कि मैंने पहले लिखे गए विभिन्न सहसंबंध कार्यक्रमों के साथ दिखाया था, और अन्य जैसे के रूप में बुरा Xoshiro ** के लिए प्रदर्शन कार्यक्रम को दोहराता है ।

इसके अलावा, PRNGs जो अपने पूरे राज्य को नहीं मिलाते हैं, में एक लंबा इतिहास है, जिसमें XorWow, संख्यात्मक व्यंजनों में जनरेटर आदि शामिल हैं, सेबेस्टियानो का तर्क देखने के बिंदु का प्रतिनिधित्व करता है, लेकिन उनका तर्क कहेगा कि किसी तरह मार्साग्लिया ने XorWow में XorWift_worse_ को एक Weyl जोड़कर बनाया। अनुक्रम, क्योंकि यह समान जनरेटर की एक विशाल संख्या बनाता है।

ऐसा लगता है जैसे हम यहां एक-दूसरे से बात कर रहे हैं। मैंने नहीं कहा कि मैं किसी भी PRNG के लिए सहसंबद्ध, गैर-अतिव्यापी दृश्यों के साथ आ सकता हूं, मैंने कहा कि मैं सामान्य रूप से पैथोलॉजिकल सीडिंग के साथ आ सकता हूं, जैसा कि मैंने पहले लिखे गए विभिन्न सहसंबंध कार्यक्रमों के साथ दिखाया था, और अन्य जैसे के रूप में बुरा Xoshiro ** के लिए प्रदर्शन कार्यक्रम को दोहराता है ।

कृपया तकनीकी स्तर पर चर्चा को बनाए रखने का प्रयास करें। "पैथोलॉजिकल" का कोई गणितीय अर्थ नहीं है।

स्व-सहसंबंध के लिए जाँच करने का तकनीकी रूप से सही तरीका दो बीजों को दो गैर-अतिव्यापी दृश्यों (परीक्षण की अवधि के लिए गैर-अतिव्यापी) में मिल रहा है - वे अपरिहार्य रूप से ओवरलैप करेंगे यदि आप बहुत दूर जाते हैं), उन्हें इंटरलेव करें और इसे बैटरी में पास करें परीक्षण के।

यदि आप दो अनुक्रमों पर विचार करते हैं जो ओवरलैप करते हैं, तो उन्हें हर जनरेटर के लिए सहसंबंधित किया जाएगा, यहां तक ​​कि एक क्रिप्टो एक, सिर्फ इसलिए कि अनुक्रमों के ओवरलैप के बाद एक ही आउटपुट दो बार होगा, और कोई भी उचित परीक्षण उसे उठाएगा।

ओवरलैपिंग दृश्यों का उपयोग करते हुए "पैथोलॉजिकल सीडिंग" हर जनरेटर (जो भी "पैथोलॉजिकल" साधन) के लिए एक तुच्छ कार्य है।

एक बार फिर, चूंकि आप दावा करते हैं कि पीसीजी के समान सहसंबंध पाया गया है (जिसमें अनुक्रम ओवरलैपिंग नहीं कर रहे हैं, जैसा कि अन्य जनरेटर में परीक्षण दिखाता है), क्या आप xoshiro256 ++ या SFC64 से, सहसंबद्ध, गैर-अतिव्यापी अनुक्रमों की एक जोड़ी प्रदान कर सकते हैं। ?

स्व-सहसंबंध के लिए जाँच करने का तकनीकी रूप से सही तरीका दो बीजों को दो गैर-अतिव्यापी दृश्यों (परीक्षण की अवधि के लिए गैर-अतिव्यापी) में मिल रहा है - वे अपरिहार्य रूप से ओवरलैप करेंगे यदि आप बहुत दूर जाते हैं), उन्हें इंटरलेव करें और इसे बैटरी में पास करें परीक्षण के।

क्या आप सहसंबंध की इस परिभाषा के लिए साहित्य की ओर इशारा कर सकते हैं ताकि मैं यह सुनिश्चित कर सकूं कि मैं "तकनीकी रूप से सही" रहूं?

सेबेस्टियानो, आप मुझे अपनी शर्तों पर एक चुनौती का जवाब देने के लिए चाहते हैं। आप जो इंगित कर रहे हैं वह एलसीजी के आंतरिक गुणों से संबंधित है, जहां आत्म-समानता है। आपको एक अराजक PRNG या LFSR- आधारित एक ही समस्या नहीं मिलेगी।

लेकिन अन्य PRNG के लिए अन्य कमजोर स्पॉट होंगे।

LFSR में ज़ेरोलैंड, ख़राब अवस्थाएँ, हामिंग-वेट इश्यू, रैखिकता, और जैसा कि हमने xoshiro के साथ आपके प्रयासों से सीखा है, कभी-कभी अन्य विचित्रताएँ जैसे दोहराव के साथ अजीब समस्याएं।

अराजक PRNGs में छोटे चक्रों का जोखिम होता है (हालांकि काउंटर वाले लोग इससे बचते हैं - वीइल अनुक्रम FTW!) और उनके आंतरिक पूर्वाग्रह।

यदि अनुक्रम ओवरलैप करते हैं, जैसा कि मैंने लिखा है, परीक्षण _always_ विफल होगा। आपको यह समझने के लिए साहित्य की आवश्यकता नहीं है कि एक परीक्षण कि _always विफल_ एक परीक्षण नहीं है।

एक बार फिर, चूंकि आप दावा करते हैं कि पीसीजी के समान सहसंबंध पाया गया है (जिसमें अनुक्रम ओवरलैपिंग नहीं कर रहे हैं, जैसा कि अन्य जनरेटर में परीक्षण दिखाता है), क्या आप xoshiro256 ++ या SFC64 से, सहसंबद्ध, गैर-अतिव्यापी अनुक्रमों की एक जोड़ी प्रदान कर सकते हैं। ?

आप वास्तव में सवाल चकमा दे रहे हैं। यह आपके लिए बहुत आसान होगा, आपके दावों का पालन करते हुए, यदि आपके पास कोई भी ऐसा सबूत है, तो प्रदान करना।

अभी करने के लिए सबसे आसान काम एक PCG64DXSM BitGenerator जोड़ना होगा, "सस्ते गुणक" के साथ PCG64 का संस्करण और DXSM आउटपुट फ़ंक्शन। मुझे लगता है कि हर कोई इस बात से सहमत है कि XSL-RR आउटपुट फ़ंक्शन से एक कदम ऊपर है जो अब हमारे PCG64 कार्यान्वयन में है, रनटाइम प्रदर्शन को नुकसान के बिना बेहतर सांख्यिकीय रूप से प्रदर्शन कर रहा है। यह आला में एक सीधा उन्नयन है जो PCG64 BitGenerator s के लिए कार्य करता है जो हम प्रदान करते हैं। मुझे लगता है कि हमें इसे PCG64 साथ जोड़ना चाहिए।

ध्यान दें कि 64-बिट "सस्ते गुणक" में सिद्ध दोष हैं। यह एक लंबे समय से जाना जाता है:

डब्ल्यू। हॉरमैन और जी। डेरफ्लिंगर, एक पोर्टेबल यादृच्छिक संख्या जनरेटर के लिए अच्छी तरह से अनुकूल है
अस्वीकृति विधि, एसीएम ट्रांस। गणित। Softw। 19 (1993), नहीं। 4, 489–495।

सामान्य तौर पर, मापांक के वर्गमूल से छोटे गुणक अपने वर्णक्रमीय अंक f their की अंतर्निहित सीमा रखते हैं।

65-बिट गुणक का उपयोग करके सीमा को आसानी से दूर किया जा सकता है, जो संकलक सिर्फ एक अतिरिक्त "ऐड" ऑपरेशन में बदल जाएगा, शायद जनरेटर की गति को भी नहीं बदल रहा है।

गाइ स्टील और मैंने विभिन्न आकारों के सस्ते गुणकों के लिए वर्णक्रमीय स्कोर की थोड़ी और प्रकाशित सारणी पर काम किया: https://arxiv.org/pdf/2001.05304.pdf । बड़ा बेहतर है, लेकिन 64 से 65 बिट्स (राज्य के 128 बिट्स के साथ एक एलसीजी के लिए) के लिए एक योग्य अंतर है।

उदाहरण के लिए, पेपर के टेबल 7 से आपको 0x1d605bb58c8abbfd मिलता है, जिसका f has स्कोर 0.9919 है। कोई 64-बिट गुणक 0.9306 (कागज में प्रमेय 4.1) से आगे नहीं जा सकता है।

मिश्रण और सब कुछ के बाद f mix स्कोर में सुधार एक सांख्यिकीय दृष्टिकोण से पूरी तरह से ध्यान नहीं जा सकता है। लेकिन केवल एक अतिरिक्त ऐड ऑपरेशन के साथ सबसे अधिक प्रासंगिक आयाम के लिए आपको जो बड़ा सुधार मिला है, उसे देखते हुए, मुझे लगता है (ठीक है, हम सोचते हैं, या हमने पेपर नहीं लिखा होगा) यह प्रयास के लायक है।

सेबेस्टियानो, आप मुझे अपनी शर्तों पर एक चुनौती का जवाब देने के लिए चाहते हैं। आप जो इंगित कर रहे हैं वह एलसीजी के आंतरिक गुणों से संबंधित है, जहां आत्म-समानता है। आपको एक अराजक PRNG या LFSR- आधारित एक ही समस्या नहीं मिलेगी।

वाह, वहाँ पहुँचने में थोड़ा समय लगा!

LFSR में ज़ेरोलैंड, ख़राब अवस्थाएँ, हामिंग-वेट इश्यू, रैखिकता, और जैसा कि हमने xoshiro के साथ आपके प्रयासों से सीखा है, कभी-कभी अन्य विचित्रताएँ जैसे दोहराव के साथ अजीब समस्याएं।

मैं पूरी तरह सहमत हूं- इसीलिए आपको उनसे हाथापाई करनी होगी। ध्यान दें कि LFSR और F₂- रैखिक जनरेटर अलग-अलग चीजें हैं; संबंधित, लेकिन अलग।

"दोहराए जाने के साथ अजीब समस्याएं", हमेशा की तरह, एक गैर-तकनीकी शब्द है जिस पर मैं टिप्पणी नहीं कर सकता।

अराजक PRNGs में छोटे चक्रों का जोखिम होता है (हालांकि काउंटर वाले लोग इससे बचते हैं - वीइल अनुक्रम FTW!) और उनके आंतरिक पूर्वाग्रह।

[अद्यतन: मैं कोष्ठक के अवलोकन से चूक गया, इसलिए मैं अपनी टिप्पणी अपडेट कर रहा हूं।]

हां, SFC64 में ऐसे मुद्दे नहीं हैं (यह एक काउंटर का उपयोग करता है), इसलिए मैं पूरी श्रेणी के लिए सामान्यीकरण नहीं करूंगा। ध्यान से डिज़ाइन किए गए अराजक जनरेटर हैं जो कि सिद्ध करने योग्य हैं, बड़ी छोटी चक्र लंबाई।

"दोहराए जाने के साथ अजीब समस्याएं", हमेशा की तरह, एक गैर-तकनीकी शब्द है जिस पर मैं टिप्पणी नहीं कर सकता।

यह टिप्पणी न कर पाना अजीब लगता है क्योंकि मैंने सही शब्दजाल का उपयोग नहीं किया है - इस कार्यक्रम को चलाएं और फिर बेझिझक मुझे उचित शब्दजाल में इस मुद्दे का वर्णन करने के लिए सबसे अच्छा तरीका बताएं और फिर जो भी टिप्पणी उपयुक्त लगे, प्रदान करें। मैंने कल्पना की होगी कि आपने और डेविड ब्लैकमैन ने इस मुद्दे पर चर्चा की होगी, जब यह पहली बार प्रकाश में आया था क्योंकि मैंने उसके साथ इसके बारे में पत्राचार किया था, लेकिन मैंने आपको इस पर टिप्पणी करते हुए कभी नहीं देखा।

PRNGs की चर्चा numpy ऑफ-टॉपिक में नहीं है। कृपया उस चर्चा को जारी रखने के लिए अपने स्वयं के मंचों का उपयोग करें। धन्यवाद।

@rkern - जो एक कसौटी के रूप में थोड़ा सख्त लगता है। यदि Numpy निहितार्थ में कोई कमी है जो अन्य कार्यान्वयनों द्वारा साझा नहीं की जाती है, तो चर्चा करना उचित लगता है।

मैं इस बात की पुष्टि कर सकता हूं कि जिस एक्सचेंज का मैं जिक्र कर रहा हूं, वह मुझे इस मुद्दे पर निर्णय लेने में मदद नहीं कर रहा है। जब तक हम उस पर प्रगति नहीं करेंगे, तब तक मुझे केंद्रित रहने के लिए बातचीत की आवश्यकता है।

मुझे लगता है कि व्यापक संदर्भ को समझना मददगार है। सेबेस्टियानो में पीसीजी के बारे में एक बात है और वर्षों से इसके खिलाफ रेलिंग है। मुझे लगता है कि इन दिनों कुछ लोग हम दोनों को देख सकते हैं और अपनी आँखों को रोल कर सकते हैं और कह सकते हैं कि "आप दोनों एक दूसरे के समान बुरे हैं" क्योंकि मैंने उनके PRNGs को भी क्रिटिक किया है, लेकिन वास्तव में मैंने ऐसा केवल तब किया जब वह दावा करने के आसपास चला गया कि मैं उसके सामान के बारे में कभी बात नहीं करके कुछ छिपाने की कोशिश कर रहा था (जब वास्तव में, मेरे पास समय / झुकाव नहीं था - वास्तव में, मैंने सिर्फ यह मान लिया था कि वे ठीक थे)।

हालांकि उनकी आलोचनाएं उपयोगी हैं, और मुझे खुशी है कि उन्होंने अपने काम के बारे में सोचकर अपना बहुत सारा जीवन बिताने के लिए चुना है, लेकिन यह जानना महत्वपूर्ण है कि उनके परीक्षणों की प्रकृति में प्रतिकूलता है। वह पीसीजी की संरचना के ज्ञान का उपयोग करता है ताकि आरएनजी परीक्षक और असफल परीक्षणों में खिलाया जा सके।

यह देखते हुए कि कितना डरावना लग सकता है, यह दिखाना उचित प्रतीत होता है कि एक समान प्रतिकूल दृष्टिकोण कई अन्य जनरेटर को भी यात्रा करेगा और यह कि वह पीसीजी के बारे में जो चिंताएं उठाता है वह अन्य पीढ़ी की योजनाओं पर भी लागू होगी, जैसा कि मैंने पीढ़ी योजनाओं के बारे में देखा है। XorWow की तरह, और मैं अक्सर एक उदाहरण के रूप में SplitMix का उपयोग करता हूं, जैसा कि मैं नीचे करूंगा। (हममें से कोई भी विशेष रूप से स्प्लिटमिक्स में एक या दूसरे तरीके से निवेश नहीं करता है, मैं कल्पना करूँगा।)

हम स्प्लिटमिक्स के बारे में सुपर डरावना हो सकते हैं, उदाहरण के लिए, और यह दिखाते हैं कि डिफ़ॉल्ट स्ट्रीम निरंतर के साथ, यदि हम प्रत्येक 35185-वें आउटपुट को देखते हैं, तो यह एक PRNG टेस्ट सूट में विफल हो जाता है। अरे नहीं! ऐसा इसलिए है क्योंकि आंतरिक रूप से यह एक काउंटर (वेइल अनुक्रम!) 0x9e3779b97f4a7c15 (φ, स्वर्ण अनुपात के आधार पर) बढ़ा रहा है, लेकिन 35185 * 0x9e3779b97f4a7c15 = 0x86a100000c480245 , जो केवल है 14 बिट्स सेट और बीच में कुछ भी नहीं का एक बड़ा स्वाथ। या यदि हम हर 360998717-वें आउटपुट को देखते हैं, तो हम 0x48620000800401 की आंतरिक स्थिति के अतिरिक्त होने के लिए नीचे आते हैं, जो केवल 8 बिट्स जोड़े जा रहे हैं और फिर से पूरी तरह से मुखौटा के लिए इसके आउटपुट फ़ंक्शन के लिए कुछ कठिन है। ।

हम स्प्लिटमिक्स के बारे में डराना-भड़काना जारी रख सकते हैं और कह सकते हैं कि क्या होगा, अगर मेरे पास दो धाराएँ हैं, एक जो एडिक्टिव स्थिर 0x9e3779b97f4a7c15 और 0xdaa66d2c7ddf743f , अगर हम इसमें शामिल होते हैं तो हमें खामियां दिखाई देंगी एक PRNG परीक्षण सूट !!! लेकिन ऐसा इसलिए है क्योंकि दूसरा एक दूसरे से सिर्फ 3 गुना अधिक है।

और अंत में, अगर किसी ने कहा कि "मैं आपको दोनों स्ट्रीम देने जा रहा हूं, तो उसके साथ कुछ डरावना करें!", और मान लें कि उनका आधार were ( 0x243f6a8885a308d3 ) और _e_ ( 0xb7e151628aed2a6b ), हम कह सकते हैं, निश्चित रूप से, चलो कुछ और डराने-भड़काने वाले हैं और पाई स्ट्रीम से हर 6561221343-वें आइटम को लेते हैं और इसे ई स्ट्रीम और कम-और-बेलेउड से प्रत्येक 6663276199-th आइटम के साथ इंटरमिक्स करते हैं, वे दो समान पैदा करते हैं दृश्यों। और _worse_, मैं तब यह दिखाने के लिए जाता हूं कि स्ट्रीम ए पर प्रत्येक कूद के लिए, स्ट्रीम बी पर एक ही आउटपुट देने के लिए एक मिलान कूदना है, इसलिए वास्तव में 2 ^ 64 तरीके हैं जिसमें वे सहसंबंधी हैं !!! (और हम किसी भी दो धाराओं के लिए ऐसा कर सकते हैं, _ और _e_ के बारे में कुछ विशेष नहीं था।)

PCG पर लौटना, सेबस्टियानो का परीक्षण दो PCG64 XSH RR जेनरेटरों पर निर्भर करता है, ताकि मैचिंग आउटपुट इंटरएक्टिव हो जाए। अगर हम एक छोटी राशि से PRNG में से किसी एक को आगे बढ़ाते हैं, तो सही संरेखण को केवल एक बालक तोड़ना, कुछ भी संदिग्ध का पता लगाना बहुत मुश्किल हो जाता है।

दूसरी दिशा में एक समान प्रतिकूल परीक्षण (सेबेस्टियानो पर बोझ डालना) PCG64 XSH RR से आउटपुट देने के लिए होगा जो उसके दावे को पूरा करता है कि वे सहसंबद्ध हैं लेकिन हम उसे ठीक से नहीं बताते कि वे कैसे गठबंधन कर रहे हैं (वे सिर्फ हैं सही पड़ोस में)। उनका काम यह दिखाना होगा कि वे परस्पर संबंधित हैं।

कुल मिलाकर, मुझे नहीं लगता कि यह तत्काल आग लगाने के साथ व्यवहार में एक मुद्दा है, लेकिन दूसरी तरफ, डीएक्सएसएम संस्करण बेहतर है क्योंकि पिछले साल इस तरह के मुद्दों को ठीक करने के लिए इसे लिखा गया था, और मैं ऐसा करूंगा आप इसे स्विच करने के लिए खुश हैं।

पुनश्च आप इस कोड का उपयोग करके अपने पसंदीदा असली नंबर से मैजिक वाइल एडिक्टिव स्थिरांक बना सकते हैं:

WeylConst[r_,bits_] = BitOr[Floor[(r-Floor[r])*2^bits],1]

वह गणितज्ञ है, मैं अभ्यास के रूप में पायथन संस्करण को छोड़ दूँगा।

यहां बताया गया है कि कैसे मैं अलग-अलग वेतन वृद्धि के लिए निचले-बिट टकरावों का निर्माण करता हूं।

❯ ./pcg64_correlations.py -m 58 | stdbuf -oL ./RNG_test stdin64 -tf 2 -te 1 -tlmaxonly -multithreaded
s0 = 0b01110010100110011101000110010010101111111001100011001011001011111001001110101010011101111101001101011000011100001111111111100001
s1 = 0b10110001011001100111100010000110101110011010101010011011010100011001011111001100010001101001001011010010110101001011101111111100
dist = 0x2eb6ec432b0ea0f4fc00000000000000
[
    {
        "bit_generator": "PCG64",
        "state": {
            "state": 152330663589051481538402839025803132897,
            "inc": 228410650821285501905570422998802152525
        },
        "has_uint32": 0,
        "uinteger": 0
    },
    {
        "bit_generator": "PCG64",
        "state": {
            "state": 235805414096687854712168706130903874556,
            "inc": 70910205337619270663569052684874994465
        },
        "has_uint32": 0,
        "uinteger": 0
    }
]
RNG_test using PractRand version 0.93
RNG = RNG_stdin64, seed = 0x12d551b8
test set = expanded, folding = extra

rng=RNG_stdin64, seed=0x12d551b8
length= 128 megabytes (2^27 bytes), time= 2.8 seconds
  no anomalies in 891 test result(s)

rng=RNG_stdin64, seed=0x12d551b8
length= 256 megabytes (2^28 bytes), time= 9.4 seconds
  no anomalies in 938 test result(s)

rng=RNG_stdin64, seed=0x12d551b8
length= 512 megabytes (2^29 bytes), time= 18.1 seconds
  no anomalies in 985 test result(s)

rng=RNG_stdin64, seed=0x12d551b8
length= 1 gigabyte (2^30 bytes), time= 31.2 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/8]FPF-14+6/16:cross         R=  +4.9  p =  1.7e-4   unusual          
  [Low4/16]FPF-14+6/16:all          R=  +8.4  p =  2.3e-7   very suspicious  
  [Low4/16]FPF-14+6/16:all2         R=  +8.3  p =  8.1e-5   unusual          
  [Low8/32]FPF-14+6/32:all          R=  +6.3  p =  2.1e-5   mildly suspicious
  [Low8/32]FPF-14+6/16:all          R=  +5.7  p =  8.0e-5   unusual          
  ...and 1034 test result(s) without anomalies

rng=RNG_stdin64, seed=0x12d551b8
length= 2 gigabytes (2^31 bytes), time= 52.7 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low4/16]FPF-14+6/32:all          R=  +7.4  p =  2.0e-6   suspicious       
  [Low4/16]FPF-14+6/16:(0,14-0)     R=  +7.7  p =  9.4e-7   unusual          
  [Low4/16]FPF-14+6/16:all          R=  +8.0  p =  5.9e-7   suspicious       
  [Low4/16]FPF-14+6/16:all2         R= +12.2  p =  2.1e-6   mildly suspicious
  [Low4/16]FPF-14+6/4:(0,14-0)      R=  +7.9  p =  6.3e-7   mildly suspicious
  [Low4/16]FPF-14+6/4:all           R=  +5.8  p =  6.7e-5   unusual          
  [Low4/16]FPF-14+6/4:all2          R= +11.5  p =  3.1e-6   mildly suspicious
  [Low8/32]FPF-14+6/32:(0,14-0)     R=  +7.8  p =  8.4e-7   unusual          
  [Low8/32]FPF-14+6/32:all          R=  +7.3  p =  2.3e-6   suspicious       
  [Low8/32]FPF-14+6/32:all2         R= +14.3  p =  3.8e-7   suspicious       
  [Low8/32]FPF-14+6/16:(0,14-0)     R=  +7.7  p =  8.8e-7   unusual          
  [Low8/32]FPF-14+6/16:(1,14-0)     R=  +7.7  p =  9.3e-7   unusual          
  [Low8/32]FPF-14+6/16:all          R=  +6.9  p =  5.3e-6   mildly suspicious
  [Low8/32]FPF-14+6/16:all2         R= +18.3  p =  8.0e-9   very suspicious  
  ...and 1078 test result(s) without anomalies

rng=RNG_stdin64, seed=0x12d551b8
length= 4 gigabytes (2^32 bytes), time= 90.2 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/8]BCFN_FF(2+0):freq         R= +14.8  p~=   6e-18     FAIL !         
  [Low1/8]BCFN_FF(2+1):freq         R=  +7.4  p~=   1e-6    mildly suspicious
  [Low1/8]FPF-14+6/16:cross         R=  +8.4  p =  2.1e-7   very suspicious  
  [Low4/16]FPF-14+6/32:(0,14-0)     R=  +8.9  p =  8.1e-8   mildly suspicious
  [Low4/16]FPF-14+6/32:(1,14-0)     R=  +8.5  p =  1.9e-7   mildly suspicious
  [Low4/16]FPF-14+6/32:all          R=  +9.4  p =  2.4e-8   very suspicious  
  [Low4/16]FPF-14+6/32:all2         R= +23.9  p =  5.2e-11   VERY SUSPICIOUS 
  [Low4/16]FPF-14+6/16:(0,14-0)     R= +13.8  p =  2.2e-12   VERY SUSPICIOUS 
  [Low4/16]FPF-14+6/16:(1,14-0)     R= +10.0  p =  7.3e-9   suspicious       
  [Low4/16]FPF-14+6/16:all          R= +12.1  p =  8.0e-11   VERY SUSPICIOUS 
  [Low4/16]FPF-14+6/16:all2         R= +52.5  p =  1.3e-22    FAIL !!        
  [Low4/16]FPF-14+6/4:(0,14-0)      R= +12.2  p =  7.0e-11   VERY SUSPICIOUS 
  [Low4/16]FPF-14+6/4:all           R=  +7.1  p =  3.7e-6   mildly suspicious
  [Low4/16]FPF-14+6/4:all2          R= +29.8  p =  7.1e-14    FAIL           
  [Low4/16]FPF-14+6/4:cross         R=  +5.3  p =  7.8e-5   unusual          
  [Low4/32]FPF-14+6/32:(0,14-0)     R=  +7.6  p =  1.3e-6   unusual          
  [Low4/32]FPF-14+6/32:all          R=  +6.0  p =  4.4e-5   unusual          
  [Low4/32]FPF-14+6/32:all2         R=  +9.4  p =  2.9e-5   unusual          
  [Low4/32]FPF-14+6/16:(0,14-0)     R=  +7.3  p =  2.5e-6   unusual          
  [Low4/32]FPF-14+6/16:all          R=  +6.5  p =  1.4e-5   mildly suspicious
  [Low4/32]FPF-14+6/16:all2         R=  +8.2  p =  8.0e-5   unusual          
  [Low8/32]FPF-14+6/32:(0,14-0)     R= +17.2  p =  1.7e-15    FAIL           
  [Low8/32]FPF-14+6/32:(1,14-0)     R= +12.7  p =  2.3e-11   VERY SUSPICIOUS 
  [Low8/32]FPF-14+6/32:all          R= +15.3  p =  7.9e-14    FAIL           
  [Low8/32]FPF-14+6/32:all2         R= +86.1  p =  1.2e-35    FAIL !!!       
  [Low8/32]FPF-14+6/16:(0,14-0)     R= +16.8  p =  3.5e-15    FAIL           
  [Low8/32]FPF-14+6/16:(1,14-0)     R= +12.2  p =  6.6e-11   VERY SUSPICIOUS 
  [Low8/32]FPF-14+6/16:all          R= +13.1  p =  8.9e-12   VERY SUSPICIOUS 
  [Low8/32]FPF-14+6/16:all2         R= +82.1  p =  1.7e-34    FAIL !!!       
  [Low8/32]FPF-14+6/4:(0,14-0)      R= +12.8  p =  2.0e-11   VERY SUSPICIOUS 
  [Low8/32]FPF-14+6/4:(1,14-0)      R=  +9.4  p =  2.5e-8   suspicious       
  [Low8/32]FPF-14+6/4:all           R= +10.5  p =  2.2e-9    VERY SUSPICIOUS 
  [Low8/32]FPF-14+6/4:all2          R= +42.0  p =  5.8e-19    FAIL !         
  ...and 1118 test result(s) without anomalies

❯ ./pcg64_correlations.py -m 64 --dxsm | stdbuf -oL ./RNG_test stdin64 -tf 2 -te 1 -tlmaxonly -multithreaded
s0 = 0b10001000010110111101010101010101111100100011011111011111011111001011110101111100101101101100110101110001101101111111010101111111
s1 = 0b11000101110100011001011000001110100001001111001001100101010000101100011001010111011001100000010010011100101110001110101000011100
dist = 0x3a26b19c91e6da1d0000000000000000
[
    {
        "bit_generator": "PCG64DXSM",
        "state": {
            "state": 181251833403477538233003277050491434367,
            "inc": 46073632738916603716779705377640239269
        },
        "has_uint32": 0,
        "uinteger": 0
    },
    {
        "bit_generator": "PCG64DXSM",
        "state": {
            "state": 262946148724842088422233355148768897564,
            "inc": 125105549038853892415237434774494719583
        },
        "has_uint32": 0,
        "uinteger": 0
    }
]
RNG_test using PractRand version 0.93
RNG = RNG_stdin64, seed = 0x85cea9
test set = expanded, folding = extra

rng=RNG_stdin64, seed=0x85cea9
length= 128 megabytes (2^27 bytes), time= 2.6 seconds
  no anomalies in 891 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 256 megabytes (2^28 bytes), time= 9.4 seconds
  no anomalies in 938 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 512 megabytes (2^29 bytes), time= 18.5 seconds
  no anomalies in 985 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 1 gigabyte (2^30 bytes), time= 32.3 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low4/32]BCFN_FF(2+3,13-3,T)      R=  -8.3  p =1-9.5e-5   unusual          
  ...and 1035 test result(s) without anomalies

rng=RNG_stdin64, seed=0x85cea9
length= 2 gigabytes (2^31 bytes), time= 55.8 seconds
  no anomalies in 1092 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 4 gigabytes (2^32 bytes), time= 93.1 seconds
  no anomalies in 1154 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 8 gigabytes (2^33 bytes), time= 175 seconds
  no anomalies in 1222 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 16 gigabytes (2^34 bytes), time= 326 seconds
  no anomalies in 1302 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 32 gigabytes (2^35 bytes), time= 594 seconds
  no anomalies in 1359 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 64 gigabytes (2^36 bytes), time= 1194 seconds
  no anomalies in 1434 test result(s)

rng=RNG_stdin64, seed=0x85cea9
length= 128 gigabytes (2^37 bytes), time= 2334 seconds
  no anomalies in 1506 test result(s)
...

@ क्रेंक , अपना कोड साझा करने के लिए धन्यवाद। परीक्षक में इंटरलेस्ड आउटपुट फीड करने के लिए तिरछा जोड़ने के लिए एक विकल्प जोड़ना शिक्षाप्रद होगा। ऐसा कुछ है जो मैंने थोड़ा खोजा।

हाँ, मैंने अनौपचारिक रूप से bg0.advance(N) विभिन्न N लिए अंतिम return डालने से पहले किया है। मैंने यह सुनिश्चित करने के लिए निचले -64-बिट टक्कर का उपयोग किया कि मुझे कुछ दिखाई देगा। 16 तरह छोटे बदलाव 128 32 GiB को विफलता को लम्बा खींचते हैं।

ऐसा लगता है कि हमें एक वैकल्पिक बिटगेनर के रूप में PCG64 DXSM को जोड़ना चाहिए और अंततः इसे डिफ़ॉल्ट बनाना चाहिए। क्या हमारे पास कार्यान्वयन है?

मुझे लगता है कि व्यापक संदर्भ को समझना मददगार है। सेबेस्टियानो में पीसीजी के बारे में एक बात है और वर्षों से इसके खिलाफ रेलिंग है। मुझे लगता है कि इन दिनों कुछ लोग हम दोनों को देख सकते हैं और अपनी आँखों को रोल कर सकते हैं और कह सकते हैं कि "आप दोनों एक दूसरे के समान बुरे हैं" क्योंकि मैंने उनके PRNGs को भी क्रिटिक किया है, लेकिन वास्तव में मैंने ऐसा केवल तब किया जब वह दावा करने के आसपास चला गया कि मैं उसके सामान के बारे में कभी बात नहीं करके कुछ छिपाने की कोशिश कर रहा था (जब वास्तव में, मेरे पास समय / झुकाव नहीं था - वास्तव में, मैंने सिर्फ यह मान लिया था कि वे ठीक थे)।

मुझे लगता है कि ये विचार पूरी तरह से अनुचित हैं।

बिना किसी योग्यता के और बिना किसी सबूत के अन्य लोगों के काम (जैसे, स्प्लिटमिक्स) पर हमला करने पर जोर देने से पीसीजी गड़बड़, या नम्पी के जनरेटर को बेहतर बनाने वाला नहीं है। इसके बजाय एक बेहतर गुणक, या एक बेहतर डिज़ाइन वाला स्क्रैम्बलर, मदद कर सकता है।

मैं अभी भी स्प्लिटमिक्स में सहसंबंध दिखाने वाली परीक्षा की प्रतीक्षा कर रहा हूं जब उपयोगकर्ता स्ट्रीम चुन सकता है। बस स्पष्ट होना, नम्पी के जनरेटर के लिए मैंने फॉर्म का एक बयान साबित किया

∀c ∀d ∃x ∀y सहसंबद्ध

जहाँ c, d वेतन वृद्धि ("धाराएँ") हैं, और x, y प्रारंभिक अवस्थाएँ हैं। वास्तव में, 2 ^ 72 y के हैं। यही है, कोई फर्क नहीं पड़ता कि आप कैसे सी, डी और एक्स चुनते हैं, 2 ^ 72 y के सहसंबंध दिखा रहे हैं।

स्प्लिटमिक्स के लिए आपके द्वारा दिए गए कथित संबंधित कोड से पता चलता है कि

∃c ∃d ∃x ∃y सहसंबद्ध

यही है, प्रतिकूल सी, डी, एक्स और वाई का चयन करके आप सहसंबंध दिखा सकते हैं।

दो बयानों में ताकत का अंतर काफी चौंका देने वाला है। दो बयानों को भ्रमित करने की कोशिश गलत है।

@vigna को हमारे आचार संहिता के बारे में @mattip और @rkern द्वारा अब तक दो बार चेतावनी दी जा चुकी है। "अन्य लोगों के काम को जोर देना" और "दो बयानों को भ्रमित करने की कोशिश करना शुद्ध एफयूडी है" जैसी भाषा का उपयोग करना ठीक नहीं है। इस पर अपनी अंतिम चेतावनी पर विचार करें। कृपया अपना स्वर बदलें या हम आपको _will_ पर प्रतिबंध लगाएंगे। तकनीकी तर्क अभी भी स्वागत करते हैं, कुछ और इस बिंदु पर नहीं है।

मैंने उन भावों की जगह संदेश को संशोधित किया जो तटस्थ हैं। मुझे अभी भी लगता है कि चर्चा के लिए व्यक्तिगत रूप से किसी अन्य प्रतिभागी पर हमला करना ("सेबस्टियानो में पीसीजी के बारे में थोड़ी सी बात है और वर्षों से इसके खिलाफ रेलिंग है") पूरी तरह से अनुचित है। मुझे बहुत आश्चर्य है तुम्हारे लिए नहीं है।

तीसरी और आखिरी बार, दोनों दिशाओं में स्प्लिटमिक्स के बारे में चर्चा, मुझे थोड़ी सी भी मदद नहीं कर रही है। मैं समझ सकता हूं कि आपको क्यों लगता है कि यह आवश्यक संदर्भ प्रदान करता है, या कि आप दूसरे को जवाब देने के लिए मजबूर महसूस करते हैं, लेकिन कृपया विश्वास करें कि मैं आपको सच बता रहा हूं कि यह मुझे कोई जानकारी नहीं प्रदान कर रहा है जो मुझे यहां निर्णय लेने में मदद करता है। आप दोनों की अपनी वेबसाइट्स हैं। उन्हें इस्तेमाल करें।

मैंने उन भावों की जगह संदेश को संशोधित किया जो तटस्थ हैं।

धन्यवाद।

मुझे अभी भी लगता है कि चर्चा के लिए व्यक्तिगत रूप से किसी अन्य प्रतिभागी पर हमला करना ("सेबस्टियानो में पीसीजी के बारे में थोड़ी सी बात है और वर्षों से इसके खिलाफ रेलिंग है") पूरी तरह से अनुचित है। मुझे बहुत आश्चर्य है तुम्हारे लिए नहीं है।

मुझे लगता है कि या तो वास्तव में नहीं देखना चाहते हैं। हालाँकि उस संदेश का स्वर लगभग उतना बुरा नहीं है।

यदि आप दोनों रचनात्मक कथनों @vigna और @imneme पर चिपक सकते हैं तो मैं इसकी बहुत सराहना करूँगा।

ठीक। चलो खरोंच से शुरू करते हैं: आप सुविधा और गति के लिए पावर-टू -2 मापांक के साथ एलसीजी पर आधारित कुछ प्रकार की धाराओं के साथ एक जनरेटर चाहते हैं। साहित्य बताता है कि एलसीजी योजक स्थिरांक पर आधारित धाराएँ आपको समस्याओं में ले जा सकती हैं (जैसा कि अभी होता है), लेकिन मान लें कि आप यही चाहते हैं।

128-बिट स्टेट और एक अच्छे गुणक (कम से कम 65 बिट्स) के साथ एक LCG क्यों न लें और स्प्लिटमिक्स से मिक्स फ़ंक्शन का उपयोग करके ऊपरी बिट्स को खराब कर दें, जिसका विभिन्न अनुप्रयोगों (हैशिंग, PRNG, आदि) में भारी परीक्षण किया गया है। उत्कृष्ट परिणाम दे रहे हैं?

मुझे पूरा यकीन है कि गति में अंतर मामूली होगा। और आपके पास कुछ (सांख्यिकीय) गारंटी है कि परिणाम सभी बिट्स पर निर्भर करेगा, जो यहां मुद्दा है।

यह मेरे लिए एक "जनरेटर के कंधे पर खड़े" दृष्टिकोण से अधिक लगता है कि एक जनरेटर पर कार्य मिश्रण करने से आत्म-सहसंबंध की समस्याएं हैं।

@imneme मैं क्या उपयोग कर सकता है एक ब्लॉग पोस्ट है DXSM के बारे में जो पुराने मेगा-इश्यू में इस घोषणा टिप्पणी की तुलना में लिंक करना आसान है। यह उस टिप्पणी में क्या है की तुलना में बहुत अधिक होना जरूरी नहीं है, लेकिन परीक्षण की वर्तमान स्थिति सहित जो आपने यहां उल्लेख किया है वह अच्छा होगा। यदि आप मेगा-इश्यू में से कुछ चर्चा को संक्षेप में प्रस्तुत करना चाहते थे जो उस विकास को आगे बढ़ाता है, जो उपयोगी होगा, निश्चित रूप से, लेकिन पूरी तरह से आवश्यक नहीं है।

@vigna

128-बिट स्टेट और एक अच्छे गुणक (कम से कम 65 बिट्स) के साथ एक LCG क्यों न लें और स्प्लिटमिक्स से मिक्स फ़ंक्शन का उपयोग करके ऊपरी बिट्स को खराब कर दें, जिसका विभिन्न अनुप्रयोगों (हैशिंग, PRNG, आदि) में भारी परीक्षण किया गया है। उत्कृष्ट परिणाम दे रहे हैं?

मैं माफी माँगता हूँ अगर यह भद्दा लगता है (हालांकि यह निश्चित रूप से इंगित किया जाएगा), लेकिन यह भी ईमानदारी से है: मैं आपकी वेबसाइट पर या arXiv पर कार्यान्वयन, विश्लेषण, बेंचमार्क और प्रैक्ट्रैंड परिणामों को देखने के लिए उत्सुक हूं। हम यहां (यथोचित रूप से सूचित) चिकित्सक हैं, PRNG शोधकर्ता नहीं हैं, और इस सुझाव को पूरा करने के लिए विशेष रूप से सुसज्जित नहीं हैं। मैं इसका अर्थ देख सकता हूं, लेकिन अपने निजी समय पर अन्य बाधाओं को देखते हुए, मुझे सुझाव को क्रियान्वयन और विश्लेषण तक ले जाने के लिए खर्च करने में कोई झुकाव नहीं है। यदि आप इस सुझाव को सुन्न करने के लिए संबोधित कर रहे हैं, तो हमें उस काम को करने के लिए PRNG शोधकर्ताओं की आवश्यकता है। यदि आप वास्तव में किसी और को यह सुझाव दे रहे हैं, तो अपनी वेबसाइट का उपयोग करें।

NumPy में रैंडम Generator -> BitGenerator -> SeedSequence आर्किटेक्चर का मतलब है कि यह प्लगेबल हो सकता है। मुझे लगता है कि हम चर्चा में उस बिंदु पर हैं जहां हमें बिटगेंसर के लिए पीआर खोलने के लिए किसी की आवश्यकता होती है, इसलिए हम वर्तमान में NumPy में इसके व्यावहारिक गुणों की तुलना कर सकते हैं। एक बार जब यह परियोजना का हिस्सा बन जाता है, तो हम इसका परीक्षण करना जारी रख सकते हैं और इसे डिफ़ॉल्ट बनाने का निर्णय ले सकते हैं। यह निर्णय, मुझे उम्मीद है, पर आधारित होगा

• पूर्वाग्रह की कमी (और अन्य मानदंड? मैं विशेषज्ञों की ओर इशारा करता हूं)
• प्रदर्शन
• हम जिस मानक इंटरफेस को बढ़ावा देते हैं, उसके माध्यम से विभिन्न प्रकार की स्ट्रीम के टकराव की संभावना: BitGenerator.spawn और SeedSequence ।

निजी तौर पर, इस चर्चा ने मुझे खो दिया जब यह BitGenerators के गुणों पर चर्चा करने से बचता था जो spawn इंटरफ़ेस का उपयोग करता था। एक कारण है कि हम इसे सर्वश्रेष्ठ अभ्यास के रूप में बढ़ावा देते हैं, और मुझे उम्मीद है कि भविष्य के पीआर की चर्चा NumPy उपयोगकर्ताओं के लिए सर्वोत्तम प्रथाओं पर ध्यान केंद्रित करेगी।

शायद यहाँ एक निष्कर्ष यह हो सकता है कि हम spawn को एक विधि के रूप में अनुमति दें, क्योंकि jumped या advance अच्छी प्रथाओं का पालन कर सकते हैं। इस पर केंद्रित एक नया मुद्दा या एनईपी भी उत्पादक हो सकता है।

@mattip लो -बिट्स जन्मदिन की टक्कर कि @vigna ने हमारे SeedSequence.spawn() इंटरफ़ेस को भी प्रभावित किया है। कृपया आश्वस्त रहें कि मैंने जिस भी चर्चा में भाग लिया है, वह हमारे एपीआई के उचित उपयोग के लिए प्रासंगिक है।

केवल कुछ अलग-अलग जनरेटर के @rkern के पसंदीदा दृष्टिकोण का उपयोग करने के लिए कुछ #ifdef ब्लॉकों के साथ pcg64.c में लगभग 8 लाइनें जोड़ने की आवश्यकता है। Pyx / pxd अन्यथा PCG64 वर्ग के समान होगा जो केवल सही परिभाषित (PCG_DXSM = 1) और एक अद्यतन डॉकस्ट्रिंग के साथ बनाया जा रहा है।

मैं शायद इसके बारे में अधिक स्पष्ट हूँ, विशेष रूप से उन प्लेटफार्मों के लिए १२ those-बिट गणित के लिए जिन्हें इसकी आवश्यकता है।

https://github.com/rkern/numpy/compare/v1.17.4...rkern%3Awip/pcg64-dxsm

यह उससे भी आसान लग रहा था क्योंकि यह एक "सस्ते" 64 बिट गुणक का उपयोग करता है। आप बस एक नया आउटपुट मिक्सर (जो कि अपरिवर्तनीय है) जोड़ सकते हैं और फिर यादृच्छिक जनरेटर की अंतिम पंक्ति के आसपास ifdef जो LCG का आउटपुट लेता है और फिर मिक्सर को लागू करता है।

https://github.com/bashtage/randomgen/commit/63e50a63f386b5fd725025f2199898944ffccddd -879bd64ee1e2b88fec97b53bc1577f177115

अगर आप चाहते तो इस बिंदु पर मुरम हश 3 में भी जोड़ सकते थे, क्या कोई ऐसा था।

क्या if बयान संकलित होने जा रहे हैं? मुझे नहीं लगता कि हम उन्हें हॉट लूप के अंदर गुणा करना चाहते हैं।

फिर से, यह randomgen और numpy बीच के उद्देश्य के अंतर में आता है। यह मानकीकृत परिवारों को बनाने के लिए randomgen में समझ में आता है, लेकिन numpy , मुझे नहीं लगता कि यह एक अच्छा विचार है कि विरासत के कार्यान्वयन को BitGenerator सक्रिय डिफ़ॉल्ट से BitGenerator । अगर हमें किसी एक या दूसरे परफॉर्मेंस के लिए कोई मेंटेनेंस या रिफलेक्टर करना है, तो यह सिर्फ उस प्रयास को बेहतर बनाने की बजाए खराब करने वाला है।

यहां रॉबर्ट से सहमत हैं। मेरे पास 1.19.0 रिलीज में एक नया बिट जनरेटर लगाने के बारे में कोई योग्यता नहीं है, यह किसी भी मौजूदा व्यवहार को नहीं बदलेगा।

@bashtage इसके अलावा, कृपया ध्यान दें कि pcg_cm_random_r() का उपयोग करता है पूर्व आवर्ती राज्य उत्पादन के लिए के बजाय बाद आवर्ती राज्य , तो यह के साथ एक ही codepath बनाए रखने के लिए आसान के रूप में होने के लिए नहीं जा रहा है #ifdef या if स्विच।

क्या if बयान संकलित होने जा रहे हैं? मुझे नहीं लगता कि हम उन्हें हॉट लूप के अंदर गुणा करना चाहते हैं।

नहीं, NumPy में if else कुछ बनना चाहिए

#if defined(PCG_DXSM)
    pcg_output_dxsm(state.high, state.low)
#else 
   <old way>
#endif

इन्हें uint128 संस्करण में अलग से परिभाषित करने की आवश्यकता है और मैन्युअल रूप से उच्च और निम्न uint128 को स्थानांतरित करने के लिए हैंडल बैक संस्करण में।

@bashtage इसके अलावा, कृपया ध्यान दें कि pcg_cm_random_r() का उपयोग करता है पूर्व आवर्ती राज्य उत्पादन के लिए के बजाय बाद आवर्ती राज्य , तो यह के साथ एक ही codepath बनाए रखने के लिए आसान के रूप में होने के लिए नहीं जा रहा है #ifdef या if स्विच।

हम्म, मैंने @imneme संदर्भ कार्यान्वयन के खिलाफ परीक्षण किया और 2 अलग-अलग बीजों का उपयोग करके 1000 मूल्यों पर 100% मैच प्राप्त किया:

https://github.com/bashtage/randomgen/blob/master/randomgen/src/pcg64/pcg_dxsm-test-data-gen.cpp

AFAICT (और मैं गलत हो सकता है)

https://github.com/imneme/pcg-cpp/blob/master/include/pcg_random.hpp#L174

तथा

https://github.com/imneme/pcg-cpp/blob/master/include/pcg_random.hpp#L1045

इसका मतलब है कि uint_128 पथ हमेशा एक सस्ते गुणक का उपयोग कर रहा है।

मुझे यकीन नहीं है कि आप वहां क्या कहना चाह रहे हैं।

यह स्पष्ट नहीं है कि विहित PCG64 DXSM क्या है। या तो मामले में आउटपुट फ़ंक्शन केवल 64-बिट संचालन का उपयोग करता है। आपके पास किसी अन्य स्थान पर 64 बिट गुणक का उपयोग करने वाला संस्करण और भी तेज़ होता है और पोस्ट के बजाय पूर्व में लौटता है। setseq_dxsm_128_64 मौजूदा PCG64 के प्राकृतिक विस्तार की तरह लगता है और केवल आउटपुट फ़ंक्शन को बदलता है।

ओह मैं समझा। नहीं, आपने सी में लागू किए गए सी की तुलना में एक अलग सी ++ जनरेटर का उपयोग किया था। मैं cm_setseq_dxsm_128_64 के बराबर कार्यान्वित हूं जो LCG पुनरावृत्ति में "सस्ते गुणक" का उपयोग करता है, न कि setseq_dxsm_128_64 जो अभी भी LCG पुनरावृत्ति में बड़े गुणक का उपयोग करता है। "सस्ते गुणक" को डीएक्सएसएम आउटपुट फ़ंक्शन के अंदर पुन: उपयोग किया जाता है, लेकिन यह एक ऑर्थोगोनल डिज़ाइन अक्ष है।

Setseq_dxsm_128_64 क्यों पसंद नहीं करते?

@imneme ने कहा कि वह अंततः pcg64 C ++ संस्करण में cm_setseq_dxsm_128_64 इंगित करने जा रही setseq_dxsm_128_64 । सस्ते गुणक XSL-RR की तुलना में DXSM की कुछ अतिरिक्त लागत को बंद कर देता है। और मुझे लगता है कि यह वैरिएंट है कि उसने कुछ महीने परीक्षण किया।

पूर्व-पुनरावृत्त राज्य को आउटपुट करना भी प्रदर्शन टक्कर का

यहाँ कुछ समय हैं:

In [4]: %timeit p.random_raw(1000000)
3.24 ms ± 4.61 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [5]: p = rg.PCG64(mode="sequence",use_dxsm=False)

In [6]: %timeit p.random_raw(1000000)
3.04 ms ± 8.47 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [7]: import numpy as np

In [8]: p = np.random.PCG64()

In [9]: %timeit p.random_raw(1000000)
3.03 ms ± 2.54 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

सभी Ubuntu-20.04 पर, डिफ़ॉल्ट संकलक।

6% धीमा। मेरे लिए एक छोटे अंतर की तरह लगता है। NumPy / randomgen में सभी टाइमिंग देशी कोड के एक वास्तविक तंग लूप में प्राप्त करने के लिए बहुत दूर हैं।

तुलना

In [10]: x = rg.Xoroshiro128(mode="sequence")

In [11]: %timeit x.random_raw(1000000)
2.59 ms ± 35.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

क्या सी कोड (150% धीमी ??) से प्रकाशित किया गया है।

दी, numpy संदर्भ में, यह ज्यादा मायने नहीं रखता। यह C ++ के संदर्भ में अधिक मायने रखता है, जिसने क्लस्टर-महीनों के आवंटन को परीक्षण के लिए हटा दिया और आधिकारिक C ++ कोड में भविष्य के डिफ़ॉल्ट pcg64 रूप में नामांकन किया। वे numpy , IMO के लिए अनुमानित प्रेरणाएँ हैं।

स्टॉक के बीच का अंतर PCG64 और मेरे PCG64DXSM मेरी शाखा पर ("सस्ते गुणक", डीएक्सएसएम आउटपुट फ़ंक्शन, पूर्व-पुनरावृत्त राज्य का उत्पादन, अलग कोडपैथ):

[practrand]
|1> s = np.random.SeedSequence()

[practrand]
|2> pcg64 = np.random.PCG64(s)

[practrand]
|3> pcg64dxsm = np.random.PCG64DXSM(s)

[practrand]
|4> %timeit pcg64.random_raw(1000000)
100 loops, best of 3: 3.46 ms per loop

[practrand]
|5> %timeit pcg64dxsm.random_raw(1000000)
100 loops, best of 3: 2.9 ms per loop

मैं अभी भी कहता हूं कि यह दोनों के बीच केवल कुछ (अधिक से अधिक) #ifdefs , यहां तक ​​कि MSVC द्वारा एक विशेष कार्यान्वयन के साथ भी। साथ ही RSN MS यूजर्स # 13816 N का इस्तेमाल कर पाएंगे।

क्या हम कोड के दोहराव पर बहस कर रहे हैं? मैं अब तक #ifdefs साथ obfuscated कोड की कुछ पंक्तियों के बारे में चिंता की तुलना में कार्यान्वयन को खारिज कर दिया है

यह ज्यादातर सिर्फ एक मजाक था, हालांकि इसने "पीसीजी 2.0" को परिभाषित करने वाले एक बिल्कुल स्पष्ट बयान की आवश्यकता पर प्रकाश डाला (अधिमानतः कहीं न कहीं जो कि न्यूपे के गिटहब मुद्दे नहीं हैं)।

धन्यवाद, @rkern एट अल।

@imneme मैं क्या उपयोग कर सकता है एक ब्लॉग पोस्ट है DXSM के बारे में जो पुराने मेगा-इश्यू में इस घोषणा टिप्पणी की तुलना में लिंक करना आसान है। यह उस टिप्पणी में क्या है की तुलना में बहुत अधिक होना जरूरी नहीं है, लेकिन परीक्षण की वर्तमान स्थिति सहित जो आपने यहां उल्लेख किया है वह अच्छा होगा। यदि आप मेगा-इश्यू में से कुछ चर्चा को संक्षेप में प्रस्तुत करना चाहते थे जो उस विकास को आगे बढ़ाता है, जो उपयोगी होगा, निश्चित रूप से, लेकिन पूरी तरह से आवश्यक नहीं है।

क्या आपके मन में टाइम-फ्रेम है? मैं कुछ समय के लिए ऐसा करने के लिए अर्थ रखता हूं और इसे अन्य चीजों से बाहर कर दिया है, इसलिए वास्तव में एक प्रस्तावित समय सीमा मेरे लिए एक उपयोगी प्रेरक होगी। एक सप्ताह शायद? दो?

@rkern ने @vigna के हवाले से भी लिखा, जिन्होंने लिखा:

128-बिट स्टेट और एक अच्छे गुणक (कम से कम 65 बिट्स) के साथ एक LCG क्यों न लें और स्प्लिटमिक्स से मिक्स फ़ंक्शन का उपयोग करके ऊपरी बिट्स को खराब कर दें, जिसका विभिन्न अनुप्रयोगों (हैशिंग, PRNG, आदि) में भारी परीक्षण किया गया है। उत्कृष्ट परिणाम दे रहे हैं?

एफडब्ल्यूआईडब्ल्यू, इस दृष्टिकोण पर मूल पीसीजी पेपर में चर्चा की गई, जिसमें ऑफ-द-शेल्फ हैश फ़ंक्शन के रूप में _FastHash_ का उपयोग किया गया, जो कि एक बहुत ही समान रूप से मल्टी-टॉर्शिफ्ट हैश फ़ंक्शन है। मेरे परीक्षण में, यह अन्य क्रमपरिवर्तन जितना तेज़ नहीं था, लेकिन उच्च गुणवत्ता का था। सेबेस्टियानो ने पीसीजी के अपने 2018 समालोचना में इस विचार का भी उल्लेख किया है और मैं उस आलोचक के प्रति मेरी प्रतिक्रिया के इस खंड में इसकी चर्चा करता हूं।

अपने PCG समालोचना के मूल संस्करण में, वह अपना PCG संस्करण लिखकर समाप्त करता है, जिसे मैं नीचे उद्धृत करूंगा:

        #include <stdint.h>

        __uint128_t x;

        uint64_t inline next(void) {
            // Put in z the top bits of state
            uint64_t z = x >> 64;
            // Update state
            x = x * ((__uint128_t)0x2360ed051fc65da4 << 64 ^ 0x4385df649fccf645)
                  + ((__uint128_t)0x5851f42d4c957f2d << 64 ^ 0x14057b7ef767814f);
            // Compute mix
            z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
            z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
            return z ^ (z >> 31);
        }

जब से उसने अपने समालोचक के कोड को और भी तेज़ संस्करण में अपडेट किया है जो एक सस्ता गुणक का उपयोग करता है और केवल 64 बिट्स के लिए एडिटिव निरंतर नीचे काटता है,

        #include <stdint.h>

        __uint128_t x;

        uint64_t inline next(void) {
            // Put in z the top bits of state
            uint64_t z = x >> 64;
            // Update state (multiplier from https://arxiv.org/abs/2001.05304)
            x = x * ((__uint128_t)1 << 64 ^ 0xd605bbb58c8abbfd) + 0x14057b7ef767814f;
            // Compute mix
            z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
            z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
            return z ^ (z >> 31);
        }

इन दोनों प्रकारों के साथ मेरा मुद्दा यह है कि क्रमपरिवर्तन उलटा है क्योंकि छंटनी की गई अवस्था (ऊपरी आधा) को अनुमति / खंडित किया गया है - आप इसे पीछे की ओर चला सकते हैं और स्क्रैचिंग को छोड़ सकते हैं, जिसमें आप सभी अंतर्निहित खामियों के साथ एक मात्र एलसीजी छोड़ सकते हैं। मेरी प्राथमिकता पूरे राज्य को परमिट / स्कैम्बल करना है और फिर उसी का एक ट्रंकेशन आउटपुट करना है। (निश्चित रूप से, कम बिट्स को अनुमति देना / रोकना सबसे तेज़ तरीका है - हमेशा की तरह व्यापार बंद हैं। उचित लोग एक असहमत हो सकते हैं जो महत्वपूर्ण है।)

लेकिन उनके अपने पीसीजी वेरिएंट को बनाने के काम ने डीएक्सएसएम की अनुमति के लिए बहुत उपयोगी प्रेरणा प्रदान की जब मैंने लिखा था कि पिछले साल।

@charris PCG64DXSM 1.19.0 में PCG64DXSM लागू करने (लेकिन अभी तक डिफ़ॉल्ट नहीं) बनाने के लिए आपकी भूख क्या है? उस समय क्या है? मैं देख रहा हूं कि हमारे पास पहले से ही 1.19.0rc2 जारी है, जो कि नई सुविधा शुरू करने के लिए _great_ नहीं है। फिर, मैं इस मुद्दे को लेकर बाल-बाल नहीं हूँ। मैं 1.19.0 को default_rng() में परिवर्तन के बारे में हमारी नीति का दस्तावेजीकरण करने और 1.20.0 में नए सामान को प्रस्तुत करने की ओर झुका हूँ।

@rkern अंतिम

संपादित करें: यह मानते हुए कि नए कोड के साथ कोई बड़ी समस्या नहीं है, और यह नहीं लगता है कि जैसे हैं। मैं PCG64 के साथ समस्याओं के बारे में बहुत चिंतित नहीं हूं, ऐसा लगता है कि किसी को भी हमारी अनुशंसित प्रक्रियाओं का उपयोग करने में समस्या नहीं होगी।

@imneme एक सप्ताह बहुत अच्छा होगा। दो सप्ताह ठीक रहेगा। धन्यवाद!

एक सवाल है जो मैं खुद से पूछ रहा हूं जो कुछ हद तक विषय है। हम चाहते हैं कि हमारे बिट जनरेटर यादृच्छिक बिट्स का उत्पादन करें, लेकिन AFAICT, अधिकांश परीक्षण में पूर्णांक शामिल होते हैं। मौजूदा परीक्षण वास्तव में बिट्स का परीक्षण कितना अच्छा करते हैं? यदि कोई क्षेत्र के अधिक परिचित व्यक्ति उस प्रश्न का उत्तर दे सकते हैं तो मैं सबसे आभारी रहूंगा।

क्या परीक्षण किया जा रहा है बिट्स की धारा है। हम परीक्षण सॉफ़्टवेयर को PRNG का प्राकृतिक शब्द आकार बताते हैं जिसका हम आउटपुट कर रहे हैं, लेकिन केवल इतना है कि यह बिट्स के सबसे अच्छे तह को सबसे कुशलता से त्रुटि कर सकता है जो कि कम या उच्च बिट्स में फसल करते हैं। खराब PRNGs में शब्द। सॉफ्टवेयर हम सभी इन दिनों का उपयोग करने के लिए करते हैं प्रैक्ट्रेड, और इसके परीक्षणों को यहां हल्के ढंग से प्रलेखित किया गया है । पढ़ने के लिए सबसे अच्छा पेपर शायद टेस्टयू 01 , पिछले गोल्ड स्टैंडर्ड टेस्ट सूट के लिए एक है। इसके उपयोगकर्ता के गाइड में परीक्षणों पर अधिक विवरण है।

मैं माफी माँगता हूँ अगर यह भद्दा लगता है (हालांकि यह निश्चित रूप से इंगित किया जाएगा), लेकिन यह भी ईमानदारी से है: मैं आपकी वेबसाइट पर या arXiv पर कार्यान्वयन, विश्लेषण, बेंचमार्क और प्रैक्ट्रैंड परिणामों को देखने के लिए उत्सुक हूं। हम यहां (यथोचित रूप से सूचित) चिकित्सक हैं, PRNG शोधकर्ता नहीं हैं, और इस सुझाव को पूरा करने के लिए विशेष रूप से सुसज्जित नहीं हैं। मैं इसका अर्थ देख सकता हूं, लेकिन अपने निजी समय पर अन्य बाधाओं को देखते हुए, मुझे सुझाव को क्रियान्वयन और विश्लेषण तक ले जाने के लिए खर्च करने में कोई झुकाव नहीं है। यदि आप इस सुझाव को सुन्न करने के लिए संबोधित कर रहे हैं, तो हमें उस काम को करने के लिए PRNG शोधकर्ताओं की आवश्यकता है। यदि आप वास्तव में किसी और को यह सुझाव दे रहे हैं, तो अपनी वेबसाइट का उपयोग करें।

मैं आपके दृष्टिकोण को पूरी तरह से समझ सकता हूं। कोड और बेंचमार्क पेज के निचले भाग में LCG128Mix नाम के साथ कुछ वर्षों से पीसीजी (http://prng.di.unimi.it/pcg.php) की समस्याओं पर टिप्पणी कर रहा है। यह मेरे हार्डवेयर पर 2.16ns लेता है, एक Intel (R) Core (TM) i7-7700 CPU @ 3.60GHz, gcc 9.2.1 और -fno-Move-loop-invariants -fno-unroll-loops के साथ।

कोड बहुत सरल है - यह एक मानक एलसीजी को एक मानक मिश्रण फ़ंक्शन (स्टैफ़र्ड के सुधारित मुरमुरश 3 के फाइनल) के साथ जोड़ता है। मैंने इसे क्रमादेशित स्थिर रखने के लिए थोड़ा संशोधित किया:

    #include <stdint.h>
    __uint128_t x; // state
    __uint64_t c;  // stream constant (odd)

    uint64_t inline next(void) {
        // Put in z the top bits of state
        uint64_t z = x >> 64;
        // Update LCG state
        x = x * ((__uint128_t)1 << 64 ^ 0xd605bbb58c8abbfd) + c;
        // Compute mix
        z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
        z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
        return z ^ (z >> 31);
    }

जैसा कि मैंने पहले बताया था, 65-बिट कंटिन्यूशन किसी भी 64-बिट कंटिन्यू से कई गुना बेहतर है, जो कि मल्टीप्लायरों की सैद्धांतिक समस्याओं के कारण मापांक के वर्गमूल से छोटा है।

यदि आप अधिक राजसी डिजाइन में रुचि रखते हैं, तो मैं प्रैक्ट्रेड परीक्षण चलाऊंगा। हालाँकि, आपको यह ध्यान में रखना चाहिए कि इस मिक्सिंग फंक्शन से एक उत्कृष्ट जनरेटर स्प्लिटमिक्स प्राप्त हुआ, यहां तक ​​कि बहुत कमजोर अंतर्निहित जनरेटर (यह सिर्फ एडिटिव था), और छोटे राज्य (64 बिट्स) के साथ। तो यह स्प्लिटमिक्स की तुलना में सिर्फ "बेहतर" होने जा रहा है, जो कि 32TB पर प्रैक्ट्रैंड से गुजरता है।

और अंतर्निहित जनरेटर एक एलसीजी है, इसलिए आपके पास 60 से सभी सामान्य घंटियाँ और सीटी हैं: कूदता है, दूरी आदि, लेकिन आपके पास एक सांख्यिकीय गारंटी भी है कि परिणाम का हर बिट 64 बिट के उच्चतर बिट्स पर निर्भर करता है। राज्य।

यदि आपके पास कुछ अन्य जनरेटर के खिलाफ बेंचमार्क है, या अन्य संकलक का उपयोग कर रहे हैं, तो कृपया मुझे बताएं।

लेकिन, कृपया, उसी ईमानदार तरीके से: केवल अगर आप वास्तव में "मानक के घटकों का उपयोग करके" दिग्गजों के कंधों पर खड़े होने पर विचार करने में रुचि रखते हैं। मेरे समय पर भी व्यक्तिगत अड़चनें हैं, और मैं योगदान देने के लिए खुश हूं, लेकिन मैं एक ऐसे जनरेटर पर समय बिताने से बचना चाहूंगा, जिस पर विचार करने का कोई मौका नहीं है।

BTW, शामिल मल्टीप्लायरों की गुणवत्ता में सुधार करने के लिए और अधिक ठोस उपाय देने के लिए, मैंने पीसीजी डीएक्सएस और कुछ विकल्प द्वारा उपयोग किए जाने वाले वर्तमान 64-बिट मल्टीप्लायर के f scores से f₈ तक वर्णक्रमीय स्कोर की गणना की।

वर्णक्रमीय स्कोर एक गुणक की अच्छाई का न्याय करने का मानक तरीका है। 0 खराब है, 1 उत्कृष्ट है। प्रत्येक स्कोर वर्णन करता है कि आउटपुट में जोड़े, ट्रिपल्स, 4-ट्यूपल्स आदि को कितनी अच्छी तरह से वितरित किया गया है।

इन सात नंबरों को क्लासिक माप में फिर से शुरू किया जा सकता है, न्यूनतम, या एक भारित माप (पहला स्कोर, दूसरा दो से विभाजित, आदि, सामान्यीकृत), पहले स्कोर को और अधिक महत्वपूर्ण बनाने के लिए, जैसा कि टीएओसीपी में नुथ द्वारा सुझाया गया है। , और ये वर्तमान गुणक के लिए न्यूनतम और भारित माप हैं:

0xda942042e4dd58b  0.633  0.778

इससे बेहतर 64-बिट स्थिरांक हैं:

0xff37f1f758180525  0.761  0.875

यदि आप 65 बिट्स पर जाते हैं, तो अनिवार्य रूप से उसी गति से (कम से कम, LCG128Mix के लिए समान गति है) आपको बेहतर भारित माप मिलता है:

0x1d605bbb58c8abbfd  0.761  0.899

कारण यह है कि 64-बिट मल्टीप्लायरों ने अपने f₂ स्कोर (.90.93) के लिए एक आंतरिक सीमा है, जो कि नथ द्वारा नोट किया गया है, सबसे अधिक प्रासंगिक है:

0xda942042e4dd58b5  0.795
0xff37f1f758180525  0.928
0x1d605bbb58c8abbfd  0.992

तो पहले गुणक में औसत दर्जे का ier अंक होता है। दूसरा गुणक 64-बिट गुणक के लिए इष्टतम के बहुत करीब पहुंच जाता है। 65-बिट गुणक में ये सीमाएं नहीं होती हैं और इनका स्कोर 1 के बहुत करीब होता है, जो सामान्य रूप से संभव है।

पूर्णता के लिए, यहाँ सभी स्कोर हैं:

 0xda942042e4dd58b5  0.794572 0.809219 0.911528 0.730396 0.678620 0.632688 0.639625
 0xff37f1f758180525  0.927764 0.913983 0.828210 0.864840 0.775314 0.761406 0.763689 
0x1d605bbb58c8abbfd  0.991889 0.907938 0.830964 0.837980 0.780378 0.797464 0.761493

आप इन स्कोर को पुनः प्राप्त कर सकते हैं या कोड गाय स्टील के साथ अपने स्वयं के गुणक की तलाश कर सकते हैं और मैंने वितरित किया: https://github.com/vigna/CPRNG । बेहतर गुणक संबंधित पेपर से लिए गए हैं।

पीसीजी शायद सुन्न के लिए एक अच्छा डिफ़ॉल्ट प्रवण होगा, लेकिन मुझे नहीं लगता कि यह समय की कसौटी पर खड़ा होगा, क्योंकि इसमें अधिक आशाजनक हैं, लेकिन ऐसा करने के लिए कम परीक्षण किए गए तरीके। मैं निम्नलिखित में से एक का प्रस्ताव करता हूं।

आधा अराजक SFC64 एक उचित बड़े minumum अवधि के साथ सांख्यिकीय ध्वनि जनरेटर के सबसे तेज में से एक है। SFC64 में कोई जम्प फ़ंक्शंस नहीं हैं, लेकिन क्या _woutout स्पीड ओवरहेड को 2 ^ 63 ग्वारेटेड यूनिक स्ट्रीम_ को सपोर्ट करने के लिए बढ़ाया जा सकता है। बस एक के बाद एक काउंटर बढ़ाने के बजाय, एक उपयोगकर्ता द्वारा एडिटिव कंटीन्यूअस के (वी होना चाहिए) के साथ एक वीइल अनुक्रम जोड़ें। प्रत्येक विषम k एक अद्वितीय पूर्ण अवधि उत्पन्न करता है। यह Weyl निरंतर रखने के लिए अतिरिक्त 64-बिट्स राज्य की आवश्यकता है:

typedef struct {uint64_t a, b, c, w, k;} sfcw64_t; // k = stream

static inline uint64_t sfcw64_next(sfcw64_t* s) {
    enum {LROT = 24, RSHIFT = 11, LSHIFT = 3};
    const uint64_t out = s->a + s->b + (s->w += s->k);
    s->a = s->b ^ (s->b >> RSHIFT);
    s->b = s->c + (s->c << LSHIFT);
    s->c = ((s->c << LROT) | (s->c >> (64 - LROT))) + out;
    return out;
}

एक 320 बिट्स राज्य कभी-कभी अवांछनीय होता है, इसलिए मैंने इसे फिर से 256 बिट्स का उपयोग करने के लिए निचोड़ने की कोशिश की है। बदले हुए आउटपुट फ़ंक्शन पर भी ध्यान दें, जो बिट मिश्रण के लिए वेइल अनुक्रम का बेहतर उपयोग करता है। यह 128/128 बिट्स अराजक / संरचित स्थिति का उपयोग करता है, जो एक अच्छा संतुलन बनाना चाहता है:
/ संपादित करें: आउटपुट func + cleanup से rotl64 () हटाया, 6 अगस्त:

typedef struct {uint64_t a, b, w, k;} tylo64_t;

static inline uint64_t tylo64_next(tylo64_t* s) {
    enum {LROT = 24, RSHIFT = 11, LSHIFT = 3};
    const uint64_t b = s->b, out = s->a ^ (s->w += s->k);
    s->a = (b + (b << LSHIFT)) ^ (b >> RSHIFT);
    s->b = ((b << LROT) | (b >> (64 - LROT))) + out;
    return out;
}

यह वर्तमान में विसंगतियों के बिना प्रैक्ट्रैंड परीक्षण में 4 टीबी पास कर चुका है, और मैंने अभी तक बिना किसी मुद्दे के विग्ना के हेमिंग-वेट परीक्षण को चलाया, हालांकि, इन परीक्षणों को पास करना यादृच्छिक यादृच्छिक उत्पादन के लिए कोई गारंटी नहीं है, बल्कि एक परीक्षण है कि चुभन त्रुटिपूर्ण है या नहीं। )।

नोट: यह माना जाता है कि सांख्यिकीय रूप से बिट्स सेट के लगभग 50% के साथ एक अद्वितीय (अनूठे) यादृच्छिक वीइल का उपयोग करने का एक फायदा है, लेकिन केवल आगे के परीक्षण या विश्लेषण से पता चलेगा कि यह कितना महत्वपूर्ण है।

/ संपादन: सफाई।

@ टायलो-काम SFC64 पहले से ही NumPy में है, फिलॉक्स के साथ, यह डिफ़ॉल्ट जनरेटर के बारे में है।

ठीक है, मुझे नहीं पता था कि वास्तव में कौन सा लागू किया गया था, इसलिए यह केवल उन लोगों में से सबसे अनुकूल समग्र का चयन करने के बारे में है? काफी साफ है, और स्पष्ट करने के लिए धन्यवाद।

मैं अपने प्रस्तावित जनरेटर का बड़े पैमाने पर परीक्षण करने की कोशिश करूंगा कि यह कैसे दूसरों के साथ ढेर हो जाता है, और अब तक यह गति, आउटपुट गुणवत्ता, सादगी / आकार / पोर्टबेलिटी, और बड़े पैमाने पर समानांतर उपयोग के बारे में बहुत अच्छा लग रहा है। लेकिन मुझे खुशी होगी अगर दूसरों ने भी इसका परीक्षण किया।

NumPy में संस्करण मानक संस्करण है जिसमें k=1 ।

https://github.com/numpy/numpy/blob/ad30b31af0bb3fbfdc0f11486807edc76cec2680/numpy/random/src/scc64/sfc64.h#L25 -L33 -L33

मुझे नहीं लगता कि हम खरोंच से डिफ़ॉल्ट PRNG के बारे में चर्चा को फिर से खोल रहे हैं। हमारे पास अपने वर्तमान PRNG के साथ एक बहुत ही विशिष्ट मुद्दा है और उस विशिष्ट मुद्दे को संबोधित करने वाले उपलब्ध, बारीकी से संबंधित वेरिएंट को देख रहे हैं। हमारी चिंताओं में से एक यह है कि मौजूदा डिफ़ॉल्ट PRNG PRNG की कुछ विशेषताओं को उजागर करता है, जैसे जंपबिलिटी, कि यह जिस वेरिएंट की जगह लेता है वह अभी भी उजागर होना चाहिए। SFC64 (या तो हमारा या आपका) की सुविधा नहीं है।

यह संभव है कि @bashtage SFC64 के अपने यादृच्छिक के लिए एक पीआर को स्वीकार करने के लिए तैयार हो।

@ tylo-work यदि आप समानांतर निष्पादन में दिलचस्प हैं, तो आप NumPy के सीडसपेंस कार्यान्वयन को देखना चाहते हैं।

मुझे नहीं लगता कि हम खरोंच से डिफ़ॉल्ट PRNG के बारे में चर्चा को फिर से खोल रहे हैं। हमारे पास अपने वर्तमान PRNG के साथ एक बहुत ही विशिष्ट मुद्दा है और उस विशिष्ट मुद्दे को संबोधित करने वाले उपलब्ध, बारीकी से संबंधित वेरिएंट को देख रहे हैं।

मान लें कि आप कुछ पीसीजी-डीएक्सएस-जैसे चाहते हैं, तो आगे और सुधार हैं जो आप सिर्फ बेहतर स्थिरांक (और बहुत मामूली मंदी) के साथ कर सकते हैं। उदाहरण के लिए, पीसीजी-डीएक्सएस जल्द ही दो अलग-अलग प्रकार के परीक्षणों में विफल हो जाएगा, जिनमें दो इंटरलेव्ड, सहसंबद्ध अनुवर्ती 112 बिट्स राज्य के साथ होंगे:

rng=PCGDXS_int112, seed=0x4d198651
length= 128 gigabytes (2^37 bytes), time= 5700 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/64]TMFn(0+2):wl             R= +57.3  p~=   2e-27     FAIL !!
  [Low8/64]FPF-14+6/64:(1,14-0)     R= +17.5  p =  8.0e-16    FAIL
  [other failures in the same tests]
  ...and 1893 test result(s) without anomalies

ध्यान दें कि हम सिर्फ 565536 सहसंबद्ध अनुक्रमों के बारे में बात कर रहे हैं - इससे डरने की कोई बात नहीं है।

लेकिन आप 0x1d605bb58c8abbfd जैसे बेहतर गुणक, और 0x9e3779b97f4a7c15 जैसे बेहतर मिक्सर का चयन करके जनरेटर में सुधार कर सकते हैं। पहला नंबर 65-बिट गुणक है जिसमें बहुत बेहतर वर्णक्रमीय स्कोर हैं। दूसरी संख्या 64-बिट फ़िक्सपॉइंट प्रतिनिधित्व में सिर्फ सुनहरा अनुपात है, और यह अच्छा मिश्रण गुण होने के लिए जाना जाता है (गुणक हैशिंग पर नथ टीओसीपी देखें); उदाहरण के लिए, इसका उपयोग हैश कलेक्शंस को मिक्स करने के लिए एक्लिप्स कलेक्शंस लाइब्रेरी द्वारा किया जाता है।

परिणामस्वरूप, आप डेटा की समान राशि के लिए केवल एफपीएफ को विफल करते हैं:

rng=PCG65-DXSϕ_int112, seed=0x4d198651
length= 128 gigabytes (2^37 bytes), time= 5014 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/64]FPF-14+6/64:(0,14-0)     R= +16.1  p =  1.5e-14    FAIL
  [other failures in the same test]
  ...and 1892 test result(s) without anomalies

वास्तव में, अगर हम 2TB PCG-DXS पर आगे बढ़ते हैं, तो समान अंतरसंबद्ध, सहसंबद्ध अनुवर्ती के लिए _three_ प्रकार के परीक्षण विफल हो जाते हैं:

rng=PCGDXS_int112, seed=0x4d198651
length= 2 terabytes (2^41 bytes), time= 53962 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/32]TMFn(0+0):wl             R= +50.2  p~=   4e-23     FAIL !!
  [Low8/64]FPF-14+6/64:(1,14-0)     R=+291.1  p =  4.7e-269   FAIL !!!!!!
  [Low8/64]Gap-16:B                 R= +19.5  p =  1.4e-16    FAIL !
  [other failures in the same tests]
  ...and 2153 test result(s) without anomalies

जबकि PCG65-DXSϕ अभी भी सिर्फ FPF विफल रहता है:

rng=PCGDXS65ϕ_int112, seed=0x4d198651
length= 2 terabytes (2^41 bytes), time= 55280 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/64]FPF-14+6/64:(0,14-0)     R=+232.1  p =  2.0e-214   FAIL !!!!!!
  [other failures in the same test]
  ...and 2153 test result(s) without anomalies

जल्दी या बाद में, निश्चित रूप से, PCG65-DXS fail गैप और TMFn को भी विफल कर देगा। लेकिन आपको PCG-DXS की तुलना में बहुत अधिक आउटपुट देखने की आवश्यकता है।

यह PCG65-DXS which के लिए पूर्ण कोड है, जो बेहतर स्थिरांक के साथ सिर्फ PCG-DXS है:

#include <stdint.h>

__uint128_t x; // State
uint64_t c; // Additive constant

static inline uint64_t output(__uint128_t internal) {
    uint64_t hi = internal >> 64;
    uint64_t lo = internal;

    lo |= 1;
    hi ^= hi >> 32;
    hi *= 0x9e3779b97f4a7c15;
    hi ^= hi >> 48;
    hi *= lo;
    return hi;
}

static uint64_t inline next(void) {
    __uint128_t old_x = x;
    x = x *  ((__uint128_t)1 << 64 ^ 0xd605bbb58c8abbfd) + c;
    return output(old_x);
}

सीमांत मंदी एक ऐड निर्देश (65-बिट गुणक के कारण) के कारण है, और लोड करने के लिए दो 64-बिट स्थिरांक हैं।

मैं सामान्य रूप से इस तरह के जनरेटर का समर्थन नहीं कर रहा हूं, लेकिन पीसीजी 65-डीएक्सएस meas सहसंबंध को छिपाने में पीसीजी-डीएक्सएस से बेहतर है।

@ विग्ना , FYI करें, मैंने कुछ इंटरलेविंग टेस्टिंग भी की, और देखा कि 128 इंटरलेव्ड स्ट्रीम या अधिक बनाते समय xoshiro256 ** जल्दी से विफल हो गया। 256 के साथ यह जल्दी विफल हो गया। परीक्षण का बिंदु यह जांचना है कि जब प्रत्येक धारा कुछ रैखिक निर्भरताओं के साथ आरम्भ की गई थी, तो PRNG कितना अच्छा व्यवहार करते हैं। अनिवार्य रूप से, राज्य s[0]=s[1]=s[2]=s[3] = k1 + stream*k2 लिए आरंभिक है। फिर 12 आउटपुट को छोड़ दिया जाता है, जो मूल रूप से sfc64 को इनिशियलाइज़ कैसे किया जाता है।

मुझे पता है, यह जोशीरो के लिए अनुशंसित आरंभीकरण नहीं है, लेकिन यह अभी भी दिलचस्प है - और थोड़ी चिंता की बात है - कि कुछ इंटरलेविंग धाराओं के साथ परीक्षण जोशीरो के लिए ठीक लग रहा था, लेकिन कई के साथ असफल रहा।

seed: 1591888413
RNG_test using PractRand version 0.95
RNG = RNG_stdin64, seed = unknown
test set = core, folding = standard (64 bit)
...
rng=RNG_stdin64, seed=unknown
length= 2 gigabytes (2^31 bytes), time= 29.6 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/64]FPF-14+6/16:(1,14-1)     R=  +7.2  p =  3.7e-6   unusual
  [Low1/64]FPF-14+6/16:all          R=  +9.6  p =  1.8e-8   very suspicious
  ...and 261 test result(s) without anomalies

rng=RNG_stdin64, seed=unknown
length= 4 gigabytes (2^32 bytes), time= 55.5 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low1/64]FPF-14+6/16:(0,14-0)     R= +13.4  p =  4.7e-12   VERY SUSPICIOUS
  [Low1/64]FPF-14+6/16:(1,14-0)     R=  +9.4  p =  2.6e-8   suspicious
  [Low1/64]FPF-14+6/16:(2,14-1)     R=  +7.7  p =  1.3e-6   unusual
  [Low1/64]FPF-14+6/16:all          R= +17.4  p =  8.8e-16    FAIL !
  ...and 275 test result(s) without anomalies

मैंने SFC64 और TYLO64 के लिए इनिशियलाइज़ेशन को कमज़ोर करने की कोशिश की, केवल 2 आउटपुट को छोड़ने के लिए, हालांकि वे अभी भी ठीक लग रहे थे।
प्रदर्शन पर: xoshiro256 ** मेरी मशीन पर दो अन्य लोगों की तुलना में 33% धीमा चलता है। TYLO64 केवल 196 बिट्स स्टेट वेरिएंट को अपडेट करता है। यहाँ परीक्षण कार्यक्रम है:

int main()
{
    //FILE* f = freopen(NULL, "wb", stdout);  // Only necessary on Windows, but harmless.
    enum {THREADS = 256};
    uint64_t seed = 1591888413; // <- e.g. this fails. // (uint64_t) time(NULL); 
    fprintf(stderr, "seed: %lu\n", seed);

    static tylo64_t tyl[THREADS];
    static sfc64_t sfc[THREADS];
    static uint64_t xo[THREADS][4];

    for (size_t i = 0; i < THREADS; ++i) {
    tyl[i] = tylo64_seed(seed + (12839732 * i), 19287319823 * i);
    sfc[i] = sfc64_seed(seed + (12839732 * i));
    xo[i][0] = xo[i][1] = xo[i][2] = xo[i][3] = seed + (12839732 * i);
    for (int j=0; j<12; ++j) xoshiro256starstar_rand(xo[i]);
    }
    static uint64_t buffer[THREADS];
    size_t n = 1024 * 1024 * 256 / THREADS;

    while (1/*n--*/) {
        for (int i=0; i<THREADS; ++i) {
        //buffer[i] = tylo64_rand(&tyl[i]);
        //buffer[i] = sfc64_rand(&sfc[i]);
            buffer[i] = xoshiro256starstar_rand(xo[i]);
        }
        fwrite((void*) buffer, sizeof(buffer[0]), THREADS, stdout);
    }
    return 0;
}

मैं कुछ प्रासंगिक हेडर कोड शामिल करूंगा:

typedef struct {uint64_t a, b, w, k;} tylo64_t; // k = stream

static inline uint64_t tylo64_rand(tylo64_t* s) {
    enum {LROT = 24, RSHIFT = 11, LSHIFT = 3};
    const uint64_t b = s->b, w = s->w, out = (s->a + w) ^ (s->w += s->k);
    s->a = (b + (b << LSHIFT)) ^ (b >> RSHIFT);
    s->b = ((b << LROT) | (b >> (64 - LROT))) + out;
    return out;
}

/* stream in range [0, 2^63) */
static inline tylo64_t tylo64_seed(const uint64_t seed, const uint64_t stream) {
    tylo64_t state = {seed, seed, seed, (stream << 1) | 1};
    for (int i = 0; i < 12; ++i) tylo64_rand(&state);
    return state;
}

static inline uint64_t rotl(const uint64_t x, int k) {
    return (x << k) | (x >> (64 - k));
}
static inline uint64_t xoshiro256starstar_rand(uint64_t* s) {
    const uint64_t result = rotl(s[1] * 5, 7) * 9;
    const uint64_t t = s[1] << 17;
    s[2] ^= s[0];
    s[3] ^= s[1];
    s[1] ^= s[2];
    s[0] ^= s[3];
    s[2] ^= t;
    s[3] = rotl(s[3], 45);
    return result;
}

@ tylo-work मैं विश्लेषण की सराहना करता हूं, लेकिन मुझे ध्यान केंद्रित रहने के लिए वास्तव में इस मुद्दे की आवश्यकता है। यदि आप चर्चा की उस पंक्ति को जारी रखना चाहते हैं, तो मैं आपको प्रोत्साहित करता हूं कि आप अपने काम को अपने गितुब रेपो में पोस्ट करें, और एक और पोस्ट यहां लोगों को आमंत्रित करने के लिए करें। बाकी सब, कृपया वहां जवाब दें। आपके सहयोग के लिए धन्यवाद।

@imneme @rkern टाइम 1.19 रिलीज के लिए चल रहा है।

PCG64DXSM की तरह

क्षमा करें, मैं कुछ अन्य असंबंधित मामलों से निपट रहा हूं। हमारी चर्चा के आधार पर, मुझे नहीं लगता कि एक छोटी सी देरी एक बड़ा मुद्दा है, क्योंकि PCG64DXSM को एक वैकल्पिक विकल्प के रूप में योजना बनाई गई थी, न कि एक नया डिफ़ॉल्ट (अभी के लिए, कम से कम)।

अब जब 1.20 शुरू हो रहा है, तो क्या यह फिर से शुरू करने और DXSM में जाने का समय है?

ब्रांचिंग से पहले इस कदम को करने के लिए हमारे पास अभी भी कुछ समय होगा, लेकिन अगले सप्ताह के भीतर इस पर शुरुआत करना अच्छा हो सकता है। @bashtage मुझे लगता है कि आपके पास जाने के लिए PCG64DXSM तैयार है और इसे मुख्य रूप से डिफ़ॉल्ट स्ट्रीम पर स्विच को फ्लिप करने के निर्णय की आवश्यकता है?

यह जो देखता है, उससे ऐसा लगता है कि हमें 1.20 के लिए ऐसा करना चाहिए अगर हमारे पास यह आसानी से उपलब्ध है।

IIRC, हम एक ऐसे संदर्भ की प्रतीक्षा कर रहे हैं जिसे लिंक किया जा सके। लेकिन अगर यादृच्छिक संख्या वाले लोग इस बदलाव से खुश हैं तो हमें इसका उपयोग करना चाहिए। क्या हमें विंडोज़ के लिए किसी विशेष कोड की आवश्यकता है?

यह सिर्फ एक अलग स्थिरांक और एक अलग स्क्रैचिंग फंक्शन है। विंडोज पर मूल PCG64 कार्यान्वयन के लिए @rkern ने जो लिखा उससे अधिक उपन्यास कुछ भी नहीं है। मुझे लगता है कि निर्णय कुछ कोड (प्रदर्शन के लिए) साझा करने के बजाय पूरी तरह से स्टैंडअलोन PCG64DXSM था।

शायद rkern की WIP शाखा से शुरू करने के लिए समझ में आता है।

मैंने कहा कि मैं इसके बारे में कुछ ब्लॉग पोस्ट लिखूंगा , जो मुझे लगता है कि @rkern को एक और भी अधिक मजबूत उत्पादन क्रमांकन पसंद आया होगा, लेकिन ऐसा करने से या तो आपको गति की लागत