अपराधों के बड़े सरणियों का संपीड़न

अभाज्य संख्याओं के गुण शायद ही कभी आपको उनके साथ एक पूर्व-संगणित सरणी के रूप में अलग-अलग काम करने की अनुमति देते हैं - और संभवत: संभव के रूप में स्वैच्छिक। एक या किसी अन्य अंक क्षमता के पूर्णांक के रूप में प्राकृतिक भंडारण प्रारूप कुछ नुकसानों से एक ही समय में ग्रस्त होता है जो डेटा वॉल्यूम के विकास के साथ महत्वपूर्ण हो जाते हैं।

तो, ऐसी तालिका के आकार के साथ 16-बिट अहस्ताक्षरित पूर्णांकों का प्रारूप लगभग 13 किलोबाइट है, इसमें केवल 6542 प्राइम शामिल हैं: 65531 की संख्या के बाद उच्च बिट गहराई के मान हैं। ऐसी मेज केवल एक खिलौने के रूप में उपयुक्त है।

प्रोग्रामिंग में सबसे लोकप्रिय 32-बिट पूर्णांक प्रारूप बहुत अधिक ठोस दिखता है - यह आपको लगभग 203 मिलियन साधारण लोगों को संग्रहीत करने की अनुमति देता है। लेकिन इस तरह की एक तालिका पहले से ही 775 मेगाबाइट के आसपास रहती है।

64-बिट प्रारूप में और भी अधिक संभावनाएं हैं। हालाँकि, 1e + 19 मानों के क्रम की एक सैद्धांतिक शक्ति के साथ, तालिका का आकार 64 एक्सबाइट्स होगा।

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

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

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

विचार की स्पष्टता के कारण, नेटवर्क को किसी व्यक्ति द्वारा पहले से गणना किए गए अपराधों की तैयार सूचियों के कई लिंक मिलते हैं। काश, ज्यादातर मामलों में वे केवल छात्र शिल्प के लिए उपयुक्त होते हैं: एक ऐसा, उदाहरण के लिए, साइट से दूसरे स्थान पर भटकते हैं और 50% साधारण व्यक्ति शामिल होते हैं। यह राशि केवल बिना बताए विस्मित कर सकती है: यह पहले ही ऊपर उल्लेखित किया गया था कि कुछ घंटों में एक होम कंप्यूटर पर आप स्वतंत्र रूप से सभी 32-बिट सरल की तालिका की गणना कर सकते हैं, और यह चार गुना बड़ा है। संभवतः लगभग 15-20 साल पहले, इस तरह की सूची वास्तव में बिछाने समुदाय के लिए एक वीर उपलब्धि थी। आज, मल्टी-कोर मल्टी-गीगाहर्ट्ज़ और मल्टी-गीगाबाइट उपकरणों के युग में, यह अब प्रभावशाली नहीं है।

मैं साधारण लोगों की एक बहुत अधिक प्रतिनिधि तालिका के उपयोग से परिचित होने के लिए भाग्यशाली था, जिसे मैं अपने क्षेत्र प्रयोगों के लिए चित्रण और बलिदान के रूप में आगे उपयोग करूंगा। साजिश के उद्देश्य से, मैं उसे 1TPrimo कहूंगा । इसमें एक खरब से भी कम सभी अपराध शामिल हैं।

एक उदाहरण के रूप में 1TPrimo का उपयोग करना, यह देखना आसान है कि आपको किन संस्करणों से निपटना है। 64-बिट पूर्णांक प्रारूप में लगभग 37.6 बिलियन मानों की क्षमता के साथ, यह सूची 280 गीगाबाइट है। वैसे - इसका वह हिस्सा जो 32 अंकों के खातों में फिट हो सकता है, इसमें प्रतिनिधित्व संख्याओं का केवल 0.5% है। इससे यह पूरी तरह स्पष्ट हो जाता है कि किसी भी गंभीर कार्य के साथ अनिवार्य रूप से 64-बिट (या अधिक) बिट डेप्थ के लिए अनिवार्य है।

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

तालिका (छवि 2) को देखते समय पहली बात जो मन में आती है वह यह है कि इसमें लगभग समान समरूप मूल्य होते हैं जो अंतिम दशमलव स्थानों में से केवल एक या दो में भिन्न होते हैं:

बस, सबसे सामान्य, अमूर्त विचारों से: यदि फ़ाइल में बहुत अधिक डुप्लिकेट डेटा है, तो इसे अभिलेखागार द्वारा अच्छी तरह से संपीड़ित किया जाना चाहिए। वास्तव में, मानक सेटिंग्स पर लोकप्रिय 7-ज़िप उपयोगिता के साथ 1TPrimo तालिका का संपीड़न एक उच्च संपीड़न अनुपात दिया: 8.5। सच है, प्रसंस्करण समय - स्रोत तालिका के विशाल आकार के साथ - 8-कोर सर्वर पर, लगभग 80-90% के सभी कोर के औसत भार के साथ, 14 घंटे 12 मिनट था। यूनिवर्सल कंप्रेशन एल्गोरिदम को कुछ अमूर्त, डेटा के बारे में सामान्यीकृत विचारों के लिए डिज़ाइन किया गया है। कुछ विशेष मामलों में, आने वाले डेटा सेट की प्रसिद्ध विशेषताओं पर निर्मित विशेष संपीड़न एल्गोरिदम अधिक प्रभावी संकेतक प्रदर्शित कर सकते हैं, जो इस कार्य के लिए समर्पित है। और कितना प्रभावी यह नीचे स्पष्ट हो जाएगा।

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

और ऐसा लगता है कि यह अंतराल पैदा करने वाले सरल लोगों की थोड़ी गहराई पर निर्भर नहीं करता है। एक संपूर्ण खोज से पता चलता है कि 1TPrimo तालिका में विभिन्न स्थानों से लिए गए अपराधों के लिए अंतराल के विशिष्ट मान इकाइयों, दसियों, कभी-कभी सैकड़ों के भीतर झूठ बोलते हैं, और - पहले काम की सजा के रूप में - वे शायद 8-बिट की सीमा में फिट हो सकते हैं अहस्ताक्षरित पूर्णांक, यानी, बाइट्स। यह बहुत सुविधाजनक होगा, और 64-बिट प्रारूप के साथ तुलना में, यह तुरंत 8-गुना डेटा संपीड़न का नेतृत्व करेगा - बस कहीं-कहीं 7-ज़िप अभिलेखागार द्वारा प्रदर्शित स्तर पर। इसके अलावा, संपीड़न और विघटन एल्गोरिदम की सादगी सिद्धांत में 7-ज़िप की तुलना में संपीड़न और डेटा तक पहुंच दोनों की गति पर एक बड़ा प्रभाव होना चाहिए। लुभावना लगता है।

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

लेकिन अफसोस। 1TPrimo डेटा पर एक साधारण संख्यात्मक प्रयोग दिखाता है कि पहले से ही लाखों के तीसरे दसियों के अंत में (यह 1TPrimo वॉल्यूम के सौ प्रतिशत से कम है) - और फिर हर जगह - आसन्न अपराधों के बीच अंतराल नियमित रूप से 0..255 की सीमा के बाहर आते हैं।

फिर भी, थोड़ा जटिल संख्यात्मक प्रयोग से पता चलता है कि टेबल की वृद्धि के साथ पड़ोसी के बीच अधिकतम अंतराल की वृद्धि बहुत, बहुत धीमी है - जिसका अर्थ है कि विचार अभी भी किसी तरह से अच्छा है।

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

यह ध्यान दिया जाना चाहिए कि चूंकि पहले दो सरल लोगों (2 और 3) के बीच का अंतराल इस योजना में फिट नहीं होता है, तो 2 को अंतराल की तालिका से बाहर करना होगा और इस तथ्य को हर समय ध्यान में रखना होगा।

यह सरल तकनीक आपको मान सीमा 0..255 में 2 से 512 तक अंतराल को एन्कोड करने की अनुमति देती है। एक बार फिर, यह आशा जीवन में आती है कि अंतर विधि हमें बहुत अधिक शक्तिशाली अनुक्रमों को पैक करने की अनुमति देगी। और ठीक ही तो: 1TPrimo सूची में प्रस्तुत 37.6 बिलियन मानों का एक भाग केवल 6 (छह!) अंतरालों से पता चलता है जो 2..512 श्रेणी में नहीं हैं।

लेकिन यह अच्छी खबर थी; बुरी बात यह है कि ये छह अंतराल काफी स्वतंत्र रूप से सूची में बिखरे हुए हैं, और उनमें से पहला सूची के पहले तीसरे के अंत में पहले से ही होता है, शेष दो तिहाई को इस संपीड़न विधि (छवि 5: 5 के लिए अनुपयुक्त) में बदल दिया जाता है।

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

* थॉमस आर निस्ले के विषयगत स्थल के अनुसार संकलित अनुसूची ।
जो 1TPrimo सूची की शक्ति से बेहतर परिमाण के कई आदेश हैं

लेकिन यहां तक ​​कि यह बहुत धीमी प्रगति असंदिग्ध रूप से संकेत देती है: कोई व्यक्ति सूची की एक निश्चित पूर्व निर्धारित शक्ति पर ही अंतराल की एक निश्चित पूर्व निर्धारित बिट गहराई तक खुद को सीमित कर सकता है। यही है, यह एक सार्वभौमिक समाधान के रूप में उपयुक्त नहीं है।

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

और क्या दिलचस्प है: ब्लॉक संरचना के साथ 8-बिट अंतराल के प्रारूप में 64-बिट 1TPrimo तालिका का अनुवाद करने की प्रक्रिया, केवल एक प्रोसेसर कोर का उपयोग करके (समानांतरकरण के लिए, आपको कार्यक्रम की एक महत्वपूर्ण जटिलता का सहारा लेना होगा, और यह बिल्कुल इसके लायक नहीं था) और 5 से अधिक नहीं प्रोसेसर लोड का% (फ़ाइल संचालन पर बिताया गया अधिकांश समय) केवल 19 मिनट का समय लिया गया - मुझे याद है - 7-ज़िप अभिलेखागार द्वारा खर्च किए गए भार के 80-90% पर आठ कोर पर 14 घंटे।

बेशक, तालिका का केवल पहला तीसरा भाग इस अनुवाद के अधीन था, जिसमें अंतराल की सीमा 512 से अधिक नहीं है। इसलिए, यदि हम उसी 14 घंटे में पूर्ण 14 घंटे लाते हैं, तो 19 मिनट की तुलना 7-ज़िप अभिलेखागार के लगभग 5 घंटे के साथ की जानी चाहिए। संपीड़न (8 और 8.5) की तुलनात्मक मात्रा के साथ, अंतर लगभग 15 गुना है। यह देखते हुए कि प्रसारण कार्यक्रम के काम के समय के शेर का हिस्सा फ़ाइल संचालन द्वारा कब्जा कर लिया गया था, अंतर एक तेज डिस्क सिस्टम पर भी स्थिर होगा। और बौद्धिक रूप से, आठ कोर पर 7-ज़िप के ऑपरेटिंग समय को अभी भी एक धागे पर गिना जाना चाहिए, और फिर तुलना वास्तव में पर्याप्त हो जाएगी।

इस तरह के डेटाबेस से चयन अनपेक्षित डेटा की तालिका से चयन से बहुत कम समय में भिन्न होता है और फ़ाइल संचालन के समय तक लगभग पूरी तरह से निर्धारित होता है। विशिष्ट संख्या विशेष रूप से विशिष्ट हार्डवेयर पर निर्भर करती है, मेरे सर्वर पर, औसतन, एक मनमाना डेटा ब्लॉक तक पहुंच 37.8 μs लेती है, जबकि ब्लॉक के पूर्ण अनपैकिंग के लिए क्रमिक रूप से ब्लॉक - 4.2 μs प्रति ब्लॉक पढ़ने - 1 μ से कम। यही है, यह एक मानक संग्रहकर्ता के काम के साथ डेटा के विघटन की तुलना करने के लिए कोई मतलब नहीं है। और यह एक बड़ा प्लस है।

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

पहले से ही अंजीर 7 में अंतराल की उपस्थिति के ग्राफ को देखते हुए, हम यह अनुमान लगा सकते हैं कि यदि अंतराल 2, 4, 6, आदि हैं। १००, १०२, १०४, १०४, आदि के अंतराल से पहले प्रकट होते हैं, फिर पूर्व को बाद के दिनों की तुलना में बहुत अधिक घटित होते रहना चाहिए। और इसके विपरीत - यदि अंतराल 514 केवल 11.99 बिलियन से शुरू होता है, 516 - 16.2 बिलियन से शुरू होता है, और 518 - आम तौर पर केवल 87.7 बिलियन से शुरू होता है, तो वे बहुत कम ही आएंगे। यही है, एक प्राथमिकता, हम अपराधों के क्रम में अंतराल के आकार और इसकी आवृत्ति के बीच व्युत्क्रम संबंध मान सकते हैं। और इसका मतलब है - आप एक सरल संरचना का निर्माण कर सकते हैं जो उनके लिए चर-लंबाई कोड लागू करता है।

बेशक, अंतराल की आवृत्ति पर आंकड़े एक विशेष कोडिंग विधि की पसंद के लिए निर्धारित हो जाना चाहिए। सौभाग्य से, मनमाने ढंग से डेटा के विपरीत, primes के बीच अंतराल की आवृत्ति - जो अपने आप में एक सख्ती से निर्धारित की जाती है, एक बार और सभी दिए गए अनुक्रम के लिए - एक सख्ती से निर्धारित, एक बार और सभी परिभाषित विशेषता के लिए भी है।

चित्रा 7 पूरे 1TPrimo सूची के लिए अंतराल की आवृत्ति प्रतिक्रिया दिखाता है:

यहां यह फिर से उल्लेख करना आवश्यक है कि बहुत पहले primes 2 और 3 के बीच के अंतराल को ग्राफ से बाहर रखा गया है: यह अंतराल 1 है और primes के अनुक्रम में ठीक एक बार होता है, सूची की शक्ति की परवाह किए बिना। यह अंतराल इतना अजीब है कि आरक्षण को लगातार भटकाने की तुलना में साधारण लोगों की सूची से 2 को निकालना आसान है। सिम को घोषित किया जाता है कि नंबर 2 वर्चुअल प्राइम है : यह सूचियों में दिखाई नहीं देता है, लेकिन यह वहां है। उस गोफर की तरह।

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

अप्रत्याशित रूप से, यह पता चला है कि सबसे लगातार अंतराल 2 और 4 नहीं हैं, क्योंकि यह सामान्य विचारों से प्रतीत होता था, लेकिन 6, 12 और 18, इसके बाद 10 - और केवल 2 और 4 लगभग समान आवृत्ति (7 अंकों में अंतर) के साथ दशमलव बिंदु के बाद)। और आगे, संख्या 6 के शिखर मानों की बहुलता पूरे ग्राफ में पता लगाया गया है।

इससे भी अधिक दिलचस्प, ग्राफ के अनजाने में प्रकट की गई यह प्रकृति सार्वभौमिक है - और, सभी विवरणों में, अपने सभी किंक के साथ - 1TPrimo सूची द्वारा दर्शाए गए सरल अंतराल के पूरे अनुक्रम पर, यह संभावना है कि यह सरल अंतराल के किसी भी अनुक्रम के लिए सार्वभौमिक है (बेशक,) इस तरह के एक बोल्ड स्टेटमेंट को प्रमाण की आवश्यकता होती है, जिसे मैं संख्या सिद्धांत में विशेषज्ञों के कंधों पर बड़ी खुशी के साथ स्थानांतरित करता हूं)। चित्र 10 पूर्ण अंतराल के आँकड़ों (स्कारलेट लाइन) की तुलना को दर्शाता है, जो 1TPrimo सूची (अन्य रंगों की रेखाएँ) पर कई मनमाने स्थानों पर सीमित अंतराल के नमूने लिए गए हैं:

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

अंतराल की आवृत्ति की यह दिलचस्प प्रकृति चर लंबाई के कोड की तुच्छ संरचना को छोड़ने का सुझाव देती है। आमतौर पर, ऐसी संरचना में विभिन्न लंबाई और उद्देश्यों के बिट्स का एक पैकेट होता है। उदाहरण के लिए, पहले एक निश्चित संख्या आती है उपसर्ग बिट्स एक विशिष्ट मान के लिए सेट किया जाता है, उदाहरण के लिए, 0. उनके पीछे एक स्टॉप बिट है, जो उपसर्ग के पूरा होने का संकेत देना चाहिए, और, तदनुसार, इस मामले में उपसर्ग से अलग होना चाहिए: 1। उपसर्ग में कोई लंबाई नहीं हो सकती है, अर्थात्, बार-बार, नमूना तुरंत एक स्टॉप बिट के साथ शुरू हो सकता है, इस प्रकार सबसे कम अनुक्रम का निर्धारण किया जा सकता है। स्टॉप बिट आमतौर पर एक प्रत्यय द्वारा पीछा किया जाता है, जिसकी लंबाई उपसर्ग की लंबाई से कुछ पूर्व निर्धारित तरीके से निर्धारित की जाती है। , , — . , - . - (, , - ) , .

, .

और यहां एक और महत्वपूर्ण बात बताई जानी चाहिए। पहली नज़र में, मनाया गया चक्रीयता अंतराल के विभाजन को {8,10, 12 } : {2,4, 6 } , {8,10, 12 } , {14,16, 18 } और इसी तरह (प्रत्येक ट्रिपल में अधिकतम आवृत्ति वाले मान बोल्ड में चिह्नित हैं) । हालांकि, वास्तव में, यहां चक्र थोड़ा अलग है।

मैं तर्क की पूरी पंक्ति का हवाला नहीं दूंगा, जो वास्तव में, वहां नहीं है: यह एक सहज अनुमान था, विकल्प, गणना, और नमूनों की कुंद गणना की एक विधि द्वारा पूरक है जो कई दिनों तक रुक-रुक कर हुआ था। परिणामस्वरूप चक्रीयता में छह अंतराल {2,4, 6 ,8,10, 12 } , {14,16, 18 ,20,22, 24 } , {26,28, 30 ,32,34, 36 } इतने पर (अधिकतम आवृत्ति के अंतराल फिर से बोल्ड में हाइलाइट किए गए हैं)।

संक्षेप में, प्रस्तावित पैकेजिंग एल्गोरिथ्म इस प्रकार है।

सम संख्याओं के छक्कों में अंतरालों को विभाजित करने से हमें फॉर्म g = i * 12 + t में किसी भी अंतराल g का प्रतिनिधित्व करने की अनुमति मिलती है, जहां i छह का सूचकांक है जिसमें यह अंतराल होता है ( i = {0,1,2,3, ...} ) और t एक पूंछ है जो निर्धारित {2,4,6,8,10,12} किसी भी छह के लिए समान रूप से परिभाषित, बाध्य और समान के मूल्यों में से एक का प्रतिनिधित्व करता है। ऊपर हाइलाइट किए गए इंडेक्स की आवृत्ति प्रतिक्रिया इसके मूल्य के लगभग विपरीत आनुपातिक है, इसलिए छह इंडेक्स को एक चर-लंबाई कोड की तुच्छ संरचना में बदलना तर्कसंगत है, जिसका एक उदाहरण ऊपर दिया गया है। पिनर की आवृत्ति विशेषताएं आपको इसे दो समूहों में विभाजित करने की अनुमति देती हैं जिन्हें अलग-अलग लंबाई की बिट श्रृंखलाओं के साथ एन्कोड किया जा सकता है: मान 6 और 12, जो सबसे अधिक बार पाए जाते हैं, एक बिट के साथ एन्कोडेड होते हैं, मान 2, 4, 8 और 10, जो बहुत कम बार सामना किया जाता है, दो बिट्स के साथ एन्कोडेड हैं। बेशक, इन दो विकल्पों के बीच अंतर करने के लिए एक और बिट की आवश्यकता है।

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

इस ब्लॉक-इंडेक्स संरचना के अतिरिक्त, चर-लंबाई कोड का उपयोग निश्चित-बिट अंतराल की तुलना में अतिरिक्त लागतों से जटिल है।

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

चर-लंबाई कोड वाली एक तालिका के लिए, दोनों कार्यों के लिए एक ही दृष्टिकोण की आवश्यकता होती है: दोनों संख्या के आधार पर मूल्य प्राप्त करने और मूल्य द्वारा खोज के लिए। चूंकि कोड की लंबाई बदलती है, इसलिए यह पहले से ज्ञात नहीं है कि किसी विशेष ब्लॉक में कितने अंतर संग्रहीत हैं, और जिसमें वांछित मान निहित है। यह प्रयोगात्मक रूप से निर्धारित किया गया था कि 512 बाइट्स के ब्लॉक आकार (जिसमें कुछ हेडर बाइट्स शामिल हैं) के साथ, ब्लॉक क्षमता औसत मूल्य के 10-12 प्रतिशत तक जा सकती है। छोटे ब्लॉक अधिक सापेक्ष बिखराव देते हैं। उसी समय, ब्लॉक क्षमता का औसत मूल्य तालिका बढ़ने के साथ धीरे-धीरे कम हो जाता है। संख्या और मूल्य दोनों से वांछित मूल्य की खोज के लिए प्रारंभिक ब्लॉक के गलत निर्धारण के लिए अनुभवजन्य सूत्रों का चयन एक गैर-तुच्छ कार्य है। वैकल्पिक रूप से, आप अधिक जटिल और परिष्कृत अनुक्रमण का उपयोग कर सकते हैं।

वह, वास्तव में, सब है।

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

परिणाम।

तालिका 1TPrimo से चर-लंबाई कोड में अनुवादित डेटा की मात्रा, एक ब्लॉक-इंडेक्स संरचना द्वारा पूरक, यह भी नीचे वर्णित है, 26,309,295,104 बाइट्स (24.5 जीबी) की राशि, यानी संपीड़न अनुपात 11.4। जाहिर है, बढ़ती गहराई के साथ, संपीड़न अनुपात में वृद्धि होगी।

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

तालिका (चित्र 10) इस पाठ में उल्लिखित अभाज्य संख्याओं की बड़ी विशेषताओं का सारांश प्रस्तुत करती है।

संपीड़न एल्गोरिथम विवरण

नियम और अधिसूचना

P (prime): P1=3, P2=5, P3=7 ... Pn, Pn1 उनके सीरियल नंबर के अनुसार P (prime): P1=3, P2=5, P3=7 ... Pn, Pn1 हैं। एक बार फिर (और आखिरी बार) मैं इस बात पर जोर देता हूं कि P0=2 एक आभासी अभाज्य संख्या है; औपचारिक एकरूपता के लिए, इस संख्या को शारीरिक रूप से अपराधों की सूची से बाहर रखा गया है।

G (gap) - दो लगातार Gn = Pn1 - Pn; G={2,4,6,8 ...} बीच का अंतराल Gn = Pn1 - Pn; G={2,4,6,8 ...} Gn = Pn1 - Pn; G={2,4,6,8 ...} ।

D (dense) - एक अखंड रूप अंतराल में कमी: D = G/2 -1; D={0,1,2,3 ...} D = G/2 -1; D={0,1,2,3 ...} । अखंड रूप में छह अंतराल {0,1,2,3,4,5}, {6,7,8,9,10,11}, {12,13,14,15,16,17} जैसे दिखते हैं आदि

Q (quotient) - छह का सूचकांक एक अखंड रूप में कम हो गया, Q = D div 6; Q={0,1,2,3 ...} Q = D div 6; Q={0,1,2,3 ...}

R (remainder) - अखंड छह R = D mod 6. R हमेशा मान {0,1,2,3,4,5} सीमा में होता है।

किसी भी मनमाना अंतराल G से उपरोक्त विधि द्वारा प्राप्त Q और R मान, उनकी स्थिर आवृत्ति विशेषताओं के कारण, नीचे वर्णित चर-लंबाई बिट पैकेट के रूप में संपीड़न और भंडारण के अधीन हैं। एक पैकेट में Q और R मान को कूटने वाले बिट स्ट्रिंग्स को अलग-अलग तरीकों से बनाया जाता है: Q इंडेक्स को कोड करने के लिए, उपसर्ग H , फ्लक्स F और सहायक बिट S की बिट श्रृंखला का S , और infix X के बिट समूह और सहायक बिट A का उपयोग शेष R को एन्कोड करने के लिए किया जाता है R

A (arbiter) - एक बिट जो इन्फिक्स का आकार निर्धारित करता है X : 0 - एक-बिट इन्फिक्स, 1 - दो-बिट।

X (infix) - 1- या 2-बिट infix, एक साथ arbiter बिट , R सारणीबद्ध तरीके से R के मान को परस्पर निर्धारित करता है (तालिका संदर्भ के लिए इस तरह के infixes के साथ पहले छह की आवृत्ति को भी दिखाती है):

F (fluxion) एक प्रवाह है, जो Q चर लंबाई L={0,1,2...} के सूचकांक Q व्युत्पन्न है, जिसे बिट स्ट्रिंग्स (), 0, 00, 000, या 1, 01, 001 , आदि के शब्दार्थों के बीच अंतर करने के लिए डिज़ाइन किया गया है। घ।

लंबाई L की इकाइयों की एक बिट श्रृंखला 2^L - 1 रूप में व्यक्त की जाती है (संकेत ^ अर्थ है घातांक)। सी संकेतन में, एक ही मूल्य अभिव्यक्ति 1<<L - 1 द्वारा प्राप्त किया जा सकता है। फिर लंबाई L के फ्लक्सिया का मूल्य Q अभिव्यक्ति Q प्राप्त किया जा सकता है

 एफ = क्यू - (1 << एल - 1),

और अभिव्यक्ति द्वारा फ्लक्सिया से Q को पुनर्स्थापित करें

 क्यू = (1 << एल - 1) + एफ।

एक उदाहरण के रूप में, मात्रा Q = {0..15} , निम्न फ्लक्सिया बिट श्रृंखला प्राप्त की जाएगी:

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

H (header) - उपसर्ग, बिट्स की एक स्ट्रिंग जो 0 पर सेट होती है।

S (stop) - उपसर्ग को समाप्त करने के लिए 1 पर सेट थोड़ा रोकें।

वास्तव में, इन बिट्स को पहले बिट स्ट्रिंग्स में संसाधित किया जाता है, वे आपको फ़्लक्स के आकार और आर्बिटर और फ्लक्स फ़ील्ड्स की शुरुआत के दौरान अनपैकिंग या सेट के दौरान निर्धारित करने की अनुमति देते हैं - स्टॉप बिट के तुरंत बाद।

W (width) - बिट्स में पूरे कोड की चौड़ाई।

बिट पैकेट का पूरा ढांचा चित्र 11 में दिखाया गया है:

इन श्रृंखलाओं से बरामद Q और R मूल्य हमें अंतराल के प्रारंभिक मूल्य को बहाल करने की अनुमति देते हैं:

 डी = क्यू * 6 + आर,
 जी = (डी + १) * २,

और बहाल अंतराल का क्रम आपको किसी दिए गए ब्लॉक के सभी अंतराल को क्रमिक रूप से जोड़कर ब्लॉक (अंतराल के बीज ब्लॉक) के दिए गए आधार मूल्य से मूल अभाज्य संख्याओं को पुनर्स्थापित करने की अनुमति देता है।

बिट स्ट्रिंग्स के साथ काम करने के लिए, 32-बिट पूर्णांक चर का उपयोग किया जाता है, जिसमें कम से कम महत्वपूर्ण बिट्स संसाधित होते हैं और उनका उपयोग करने के बाद, पैकिंग करते समय या बाईं ओर दाईं ओर बिट्स को स्थानांतरित कर दिया जाता है।

ब्लॉक संरचना

बिट स्ट्रिंग्स के अलावा, एक ब्लॉक में बिट्स को लाने या जोड़ने के लिए आवश्यक जानकारी होती है, साथ ही एक ब्लॉक की सामग्री को निर्धारित करने के लिए।

 //      //    typedef unsigned char BYTE; typedef unsigned short WORD; typedef unsigned int LONG; typedef unsigned long long HUGE; typedef int BOOL; #define TRUE 1 #define FALSE 0 #define BLOCKSIZE (256) // :   , #define HEADSIZE (8+8+2+2+2) //   , #define BODYSIZE (BLOCKSIZE-HEADSIZE) //   . //           typedef struct { HUGE base; //  ,      HUGE card; //        WORD count; //      WORD delta; // base+delta =      WORD offset; //        BYTE body[BODYSIZE]; //    } crunch_block; //    ,   put()  get() crunch_block block; //       . // NB:  len/val  rev/rel     //  ,    ,   //    . static struct tail_t { BYTE len; //      S  A BYTE val; //  ,   A  - S BYTE rev; //    BYTE rel; //    } tails[6] = { { 4, 3, 2, 3 }, { 4, 7, 5, 3 }, { 3, 1, 0, 4 }, { 4,11, 1, 4 }, { 4,15, 3, 4 }, { 3, 5, 4, 4 } }; //             BOOL put(int gap) { // 1.      int Q, R, L; //   (),  (),   int val = gap / 2 - 1; Q = val / 6; R = val % 6; L = -1; // .., 0 - 1 val = Q + 1; while (val) { val >>= 1; L++; } //    L val = Q - (1 << L) + 1; //  val <<= tails[R].len; val += tails[R].val; //      val <<= L; //   L += L + tails[R].len; //    // 2.   val  L   buffer   put_index if (block.offset + L > BODYSIZE * 8) // !      return FALSE; Q = (block.offset / 8); //  ,      R = block.offset % 8; //     block.offset += L; //      block.count++; //     block.delta += gap; if (R > 0) //        { val <<= R; val |= block.body[Q]; L += R; } //     L = L / 8 + ((L % 8) > 0 ? 1 : 0); //     while (L-- > 0) { block.body[Q++] = (char)val; val >>= 8; } return TRUE; } //          int get_index; //         //      int get() { if (get_index >= BODYSIZE * 8) return 0; //      int val = *((int*)&block.body[get_index / 8]) >> get_index % 8; //  4   if (val == 0) return -1; // !       int Q, R, L, F, M, len; // , , , ,     L = 0; while (!(val & 1)) { val >>= 1; L++; } //  -     if ((val & 3) == 1) //       R = (val >> 2) & 1; //   else R = ((val >> 2) & 3) + 2; //   len = tails[R].rel; get_index += 2 * L + len; val >>= len; M = ((1 << L) - 1); //   F = val & M; //    Q = F + M; //   return 2 * (1 + (6 * Q + tails[R].rev)); //         } 

सुधार

यदि हम अंतराल के प्राप्त आधार को उसी 7-ज़िप आर्काइवर को खिलाते हैं, तो 8-कोर सर्वर पर डेढ़ घंटे के गहन कार्य में, यह इनपुट फ़ाइल को लगभग 5% तक संपीड़ित करने का प्रबंधन करता है। अर्थात्, संग्रहकर्ता के दृष्टिकोण से चर लंबाई के अंतराल के डेटाबेस में, अभी भी कुछ अतिरेक है। इसलिए डेटा अतिरेक को कम करने के विषय पर थोड़ा (शब्द के अच्छे अर्थ में) अटकलें लगाने का कारण है।

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

हालाँकि, लाल ग्राफ़ की कष्टप्रद ऊँचाई पारदर्शी रूप से संकेत देती है कि अन्य एन्कोडिंग विधियाँ हो सकती हैं जो ग्राफ़ को और अधिक कोमल बनाती हैं।

एक और दिशा लगातार अंतराल की आवृत्ति की जांच करने का सुझाव देती है। सामान्य विचारों से: चूंकि 6, 12, और 18 के अंतराल में आबादी की आबादी में सबसे आम हैं, तो वे अधिक बार जोड़े (युगल), त्रिगुण (ट्रिपल), और अंतराल के संयोजन की तरह पाए जाते हैं। यदि डूपलेट की पुनरावृत्ति (और शायद ट्रिपल भी ... अच्छी तरह से, अचानक!) अंतराल को कुल द्रव्यमान में महत्वपूर्ण रूप से महत्वपूर्ण बनाता है, तो यह उन्हें कुछ अलग कोड में अनुवाद करने के लिए समझ में आता है।

पूर्ण पैमाने पर प्रयोग दूसरों पर व्यक्तिगत संदेह की एक निश्चित प्रबलता को प्रकट करता है। हालाँकि, यदि पूर्ण नेतृत्व जोड़ी के लिए अपेक्षित है (6,6) - 1.37% सभी युगल के - तो इस रेटिंग के अन्य विजेता बहुत कम स्पष्ट हैं:

और, चूंकि युगल (6,6) सममित है, और अन्य सभी प्रसिद्ध युगल असममित हैं और एक ही आवृत्ति के साथ दर्पण युगल द्वारा रैंकिंग में पाए जाते हैं, ऐसा लगता है कि इस श्रृंखला में दोहरे (6,6) रिकॉर्ड को अप्रभेद्य युगल के बीच आधे में विभाजित किया जाना चाहिए (6,6) और (6,6) , जो उन्हें पुरस्कार सूची की सीमा से 0.68% दूर ले जाता है। और यह एक बार फिर से अवलोकन की पुष्टि करता है कि अपराधों के बारे में कोई भी सही अनुमान आश्चर्य के बिना नहीं हो सकता है।

तीनों के आंकड़े अंतराल के ऐसे त्रिगुणों के नेतृत्व को भी प्रदर्शित करते हैं, जो अंतराल 6 की उच्चतम आवृत्ति से आगे बढ़ते हुए सट्टा धारणा में फिट नहीं होते हैं, 12, 18. लोकप्रियता के घटते क्रम में, ट्रिपल के साथ आवृत्ति वाले नेता निम्नानुसार दिखते हैं:

आदि

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

प्रतिबंध

यह पहले से ही ऊपर उल्लेख किया गया था कि primes की क्षमता के संबंध में अंतराल के अधिकतम मूल्य में वृद्धि बहुत, बहुत धीमी है। विशेष रूप से, यह अंजीर। 6 से देखा जा सकता है कि 64-बिट अहस्ताक्षरित पूर्णांक के प्रारूप में प्रतिनिधित्व किए जा सकने वाले किसी भी अपराध के बीच का अंतराल स्पष्ट रूप से 1600 से कम होगा।

वर्णित कार्यान्वयन आपको किसी भी 18-बिट अंतराल मूल्यों को सही ढंग से पैकेज और अनपैक करने की अनुमति देता है (वास्तव में, पहली पैकेजिंग त्रुटि 442358 के इनपुट अंतराल के साथ होती है)। मुझे यह मानने के लिए पर्याप्त कल्पना नहीं है कि प्राइम अंतराल का डेटाबेस ऐसे मूल्यों तक बढ़ सकता है: ऑफहैंड यह लगभग 100-बिट पूर्णांक है, और अधिक सटीक आलस्य की गणना करने के लिए। आग के मामले में, कई बार अंतराल की सीमा का विस्तार करना मुश्किल नहीं होगा।

इस जगह को पढ़ने के लिए धन्यवाद :)