Elias omega coding

इलायस ओमेगा कोडिंग या इलायस ओमेगा कोडिंग एक universal code है जो सकारात्मक पूर्णांकों को एन्कोड करता है जिसे Peter Elias ने विकसित किया है। इस कोडिंग में, जैसे Elias gamma coding और Elias delta coding, एक पूर्णांक के सामने उसके मैग्निट्यूड का प्रतिनिधित्व एक यूनिवर्सल कोड में लगाया जाता है। हालाँकि, इलायस ओमेगा कोडिंग उस प्रीफिक्स को पुनरावृत्तिक रूप से एन्कोड करता है, इसलिए उन्हें कभी-कभी पुनरावृत्तिक इलायस कोड भी कहा जाता है।

ओमेगा कोडिंग उन अनुप्रयोगों में उपयोग किया जाता है जहाँ सबसे बड़ा एन्कोड किया हुआ मान पहले से ज्ञात नहीं हो, या छोटे मानों की तुलना में बड़े मानों की आवृत्ति अधिक हो।

एक सकारात्मक पूर्णांक N को एन्कोड करने के लिए:

1. कोड के अंत में "0" रखें।
2. अगर N = 1 है, तो रुकें; एन्कोडिंग पूरी है।
3. कोड के शुरुआत में N के बाइनरी प्रतिनिधित्व को लगाएँ। यह कम से कम दो बिट्स होगा, जिसमें पहला बिट 1 होगा।
4. N को अभी लगाए गए बिट्स की संख्या में से एक कम करके सेट करें।
5. नए N के एन्कोडिंग को लगाने के लिए चरण 2 पर वापस आएँ।

एक इलायस ओमेगा-एन्कोडेड सकारात्मक पूर्णांक को डीकोड करने के लिए:

1. एक वेरिएबल N, जिसकी वैल्यू 1 हो, से शुरुआत करें।
2. अगर अगला बिट "0" है तो रुकें। डीकोडेड नंबर N है।
3. अगर अगला बिट "1" है तो उसे N और बिट्स के साथ पढ़ें, और उस बाइनरी नंबर को नए N के रूप में उपयोग करें। चरण 2 पर वापस आएँ।

उदाहरण

ओमेगा कोड को "समूहों" के रूप में सोचा जा सकता है। एक समूह या तो एक 0 बिट है जो कोड को समाप्त करता है, या दो या अधिक बिट्स हैं जो 1 से शुरू होते हैं, जिनके बाद एक और समूह होता है।

नीचे कुछ पहले कोड दिखाए गए हैं। इसमें शामिल है उस वितरण जिसे "अनुमानित वितरण" कहते हैं, जो उन मानों के वितरण का वर्णन करता है जिनके लिए यह कोडिंग एक न्यूनतम-आकार कोड उत्पन्न करता है; विस्तृत जानकारी के लिए देखें Universal codes का practical compression से संबंध।

मान	कोड	अनुमानित प्रायिकता
1	0	1/2
2	10 0	1/8
3	11 0	1/8
4	10 100 0	1/64
5	10 101 0	1/64
6	10 110 0	1/64
7	10 111 0	1/64
8	11 1000 0	1/128
9	11 1001 0	1/128
10	11 1010 0	1/128
11	11 1011 0	1/128
12	11 1100 0	1/128
13	11 1101 0	1/128
14	11 1110 0	1/128
15	11 1111 0	1/128
16	10 100 10000 0	1/2048
17	10 100 10001 0	1/2048
...
100	10 110 1100100 0	1/8192
1000	11 1001 1111101000 0	1/131,072
10,000	11 1101 10011100010000 0	1/2,097,152
100,000	10 100 10000 11000011010100000 0	1/268,435,456
1,000,000	10 100 10011 11110100001001000000 0	1/2,147,483,648

एक googol, 10¹⁰⁰, का एन्कोडिंग 11 1000 101001100 (15 बिट्स लंबाई के हेडर) के बाद 1 googol का 333-बिट बाइनरी प्रतिनिधित्व है, जो है 10010 01001001 10101101 00100101 110010100 11000011 01111100 11101011 00001011 00100111 10000100 11000100 11001110 00001011 11110011 10001010 11001110 01000000 10001110 00100001 00011010 01111100 10101010 10110010 01000011 00001000 10101000 00101110 10001111 00010000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 अंत में एक 0, जिसकी कुल 349 बिट्स हैं।

एक googol के सौवें घटक (10¹⁰⁰⁰⁰) एक 33,220-बिट बाइनरी नंबर है। इसका ओमेगा एन्कोडिंग 33,243 बिट्स लंबा है: 11 1111 1000000111000100 (22 बिट्स), इसके बाद 33,220 बिट्स मान के, और एक अंतिम 0। Elias delta coding में, समान नंबर 33,250 बिट्स लंबा है: 000000000000000 1000000111000100 (31 बिट्स) इसके बाद 33,219 बिट्स मान के। ओमेगा और डेल्टा कोडिंग क्रमशः, सामान्य 33,220-बिट बाइनरी प्रतिनिधित्व से 0.07% और 0.09% लंबे हैं।

कोड लंबाई

एक सकारात्मक पूर्णांक साँचा:Math के एन्कोडिंग के लिए, आवश्यक बिट्स की संख्या, साँचा:Math, पुनरावृत्तिक रूप से है:

$${\begin{aligned}B(0)&=0\,,\\B(N)&=1+\lfloor \log _{2}(N)\rfloor +B(\lfloor \log _{2}(N)\rfloor )\,.\end{aligned}}$$

यानी, पूर्णांक $N$ के लिए इलायस ओमेगा कोड की लंबाई है

$$1+(1+\lfloor \log _{2}N\rfloor {})+(1+\lfloor \log _{2}\lfloor \log _{2}N\rfloor {}\rfloor {})+\cdots$$

जहाँ सम के पदों की संख्या ऊपर binary iterated logarithm से सीमित है। तथ्यात्मक रूप से, मान लें $f(x)=\lfloor \log _{2}x\rfloor {}$। हमें $N>f(N)>f(f(N))>\cdots >f^{k}(N)=1$ के लिए कुछ $k$ मिलता है, और कोड की लंबाई है $(k+1)+f(N)+f^{2}(N)+\dots +f^{k}(N)$। क्योंकि $f(x)\leq \log _{2}x$, हमारे पास $k\leq \log _{2}^{*}(N)$ है।

क्योंकि पुनरावृत्तिक लॉगरिदम सभी $\log _{2}^{n}N$ की तुलना में धीमे बढ़ता है किसी भी निश्चित $n$ के लिए, असिम्प्टोटिक वृद्धि दर $\Theta (\log _{2}N+\log _{2}^{2}N+\cdots )$ है, जहाँ सम एक से नीचे गिरने पर समाप्त होता है।

असिम्प्टोटिक ऑप्टिमैलिटी

इलायस ओमेगा कोडिंग एक असिम्प्टोटिक रूप से ऑप्टिमल प्रीफिक्स कोड है।

प्रूफ स्केच. एक प्रीफिक्स कोड को Kraft inequality का पालन करना होगा। इलायस ओमेगा कोडिंग के लिए, Kraft inequality कहता है

$$\sum _{n=1}^{\infty }{\frac {1}{2^{O(1)+\log _{2}n+\log _{2}\log _{2}n+\cdots }}}\leq 1$$

अब, समान एक संतुलन है, जो हमें एक इंटीग्रल देता है, जो हमें देता है

$$\int _{1}^{\infty }{\frac {dx}{x\times \ln x\times \ln \ln x\cdots }}\leq O(1)$$

अगर डेनोमिनेटर कुछ बिंदु $\ln ^{k}x$ पर समाप्त होता है, तो इंटीग्रल डाइवर्ज $\ln ^{k+1}\infty$ करता है। हालाँकि, अगर डेनोमिनेटर कुछ बिंदु $(\ln ^{k}x)^{1+\epsilon }$ पर समाप्त होता है, तो इंटीग्रल ${\frac {1}{(\ln ^{k}\infty )^{\epsilon }}}$ के रूप में कन्वर्ज करता है। इलायस ओमेगा कोड डाइवर्जिंग और कन्वर्जिंग के बीच के किनारे पर है।

उदाहरण कोड

एन्कोडिंग

void eliasOmegaEncode(char* source, char* dest)
{
    IntReader intreader(source);
    BitWriter bitwriter(dest);
    while (intreader.hasLeft())
    {
        int num = intreader.getInt();
        BitStack bits;
        while (num > 1) {
            int len = 0;
            for (int temp = num; temp > 0; temp >>= 1)  // calculate 1+floor(log2(num))
                len++;
            for (int i = 0; i < len; i++)
                bits.pushBit((num >> i) & 1);
            num = len - 1;
        }
        while (bits.length() > 0)
            bitwriter.putBit(bits.popBit());
        bitwriter.putBit(false);                        // write one zero
    }
    bitwriter.close();
    intreader.close();
}

डीकोडिंग

void eliasOmegaDecode(char* source, char* dest) {
    BitReader bitreader(source);
    IntWriter intwriter(dest);
    while (bitreader.hasLeft())
    {
        int num = 1;
        while (bitreader.inputBit())     // potentially dangerous with malformed files.
        {
            int len = num;
            num = 1;
            for (int i = 0; i < len; ++i)
            {
                num <<= 1;
                if (bitreader.inputBit())
                    num |= 1;
            }
        }
        intwriter.putInt(num);           // write out the value
    }
    bitreader.close();
    intwriter.close();
}

विस्तृत वर्णन

इन्हें भी देखें: Variable-length quantity#Zigzag encoding

इलायस ओमेगा कोडिंग शून्य या नकारात्मक पूर्णांकों को एन्कोड नहीं करता है। शून्य से बढ़कर सभी धनात्मक पूर्णांकों को एन्कोड करने का एक तरीका 1 जोड़ना पहले और फिर डीकोडिंग के बाद 1 घटाना है, या Levenshtein coding का उपयोग करना है। सभी पूर्णांकों को एन्कोड करने का एक तरीका एक bijection सेट करना है, जो सभी पूर्णांकों (0, 1, -1, 2, -2, 3, -3, ...) को क्रमशः धनात्मक पूर्णांकों (1, 2, 3, 4, 5, 6, 7, ...) में मैप करता है एन्कोडिंग से पहले।

इन्हें भी देखें

• Elias delta (δ) coding
• Elias gamma (γ) coding
• Even-Rodeh coding

संदर्भ ग्रंथ

• "Universal codeword sets and representations of the integers". IEEE Transactions on Information Theory 21 (2): 194–203. March 1975. doi:10.1109/tit.1975.1055349. 
• “Lossless Compression Handbook”।: 55–78। (2003)। New York, NY, USA: Academic Press। DOI:10.1016/B978-012620861-0/50004-8.

• Implementation in Python

---

 Facebook Page

 Follow us on Twitter !

Read or create/edit this page in another language

• Elias omega coding in English