View source for हैमिंग वेट

{{Short description|Number of nonzero symbols in a string}}
स्ट्रिंग का '''हैमिंग वेट''' (कंप्यूटर विज्ञान) उन प्रतीकों की संख्या है जो प्रयुक्त [[वर्णमाला]] के शून्य-प्रतीक से भिन्न होते हैं। इस प्रकार यह समान लंबाई की पूर्ण-शून्य स्ट्रिंग से [[हैमिंग दूरी]] के सामान्य है। सबसे विशिष्ट स्थिति के लिए, [[ अंश |अंश]] की स्ट्रिंग, यह स्ट्रिंग में 1 की संख्या है, या किसी दिए गए नंबर की [[बाइनरी अंक प्रणाली]] का [[अंक योग]] और टैक्सीकैब ज्यामिति या ''ℓ''₁ बिट सदिश का मानदंड इस द्विआधारी स्थिति में, इसे जनसंख्या गणना भी कहा जाता है,<ref name="Warren_2013"/> पॉपकाउंट, पार्श्व में योग,<ref name="Knuth_2009"/> या बिट योग का उपयोग किया जाता है.<ref name="HP-16C_1982"/>
 
{|class="wikitable" align="right"
|+Examples
!String
!Hamming weight
|-
|'''111'''0'''1'''
|4
|-
|'''111'''0'''1'''000
|4
|-
|00000000
|0
|-
|'''678'''0'''1234'''0'''567'''
|10
|}

{| class="infobox" style="width: 10em;"
|-
| {{Graph:Chart|type=line
|width=300
|height=200
|linewidth=1
|colors=red
|yGrid =
|x = 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256
|y = 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,1
}}
|-
| class="thumbcaption" | A plot for the population count (Hamming weight for binary numbers) for (decimal) numbers 0 to 256.<ref name="Rosetta_1"/><ref name="Rosetta_2"/><ref name="Rosetta_3"/>
|}


== इतिहास और उपयोग ==
हैमिंग वेट का नाम [[रिचर्ड हैमिंग]] के नाम पर रखा गया है, चूँकि उन्होंने इस धारणा की उत्पत्ति नहीं की थी।<ref name="Thompson_1983"/> बाइनरी संख्याओं के हैमिंग वेट का उपयोग 1899 में जेम्स व्हिटब्रेड ली ग्लैशर द्वारा पास्कल के त्रिकोण की पंक्ति में गोल्ड के अनुक्रम के लिए सूत्र देने के लिए किया गया था।<ref name="Glaisher_1899"/> इरविंग एस. रीड ने 1954 में बाइनरी स्थिति में हैमिंग वेट के सामान्य अवधारणा प्रस्तुत की थी।<ref name="Reed_1954"/>

हैमिंग वेट का उपयोग [[सूचना सिद्धांत]], [[कोडिंग सिद्धांत]] और [[क्रिप्टोग्राफी]] सहित कई विषयों में किया जाता है। हैमिंग वज़न के अनुप्रयोगों के उदाहरणों में सम्मिलित हैं:
* वर्ग द्वारा मॉड्यूलर घातांक में, घातांक e के लिए आवश्यक मॉड्यूलर गुणन की संख्या लॉग है यही कारण है कि [[आरएसए (एल्गोरिदम)]] में प्रयुक्त सार्वेटिक कीज मान e को सामान्यतः कम हैमिंग वेट की संख्या के रूप में चुना जाता है।<ref name="CLNZ"/>
*हैमिंग वेट [[कॉर्ड (वितरित हैश तालिका)]] में नोड्स के बीच पथ की लंबाई निर्धारित करता है।<ref name="Stoica_2003" />
*बायोमेट्रिक डेटाबेस में [[आईरिसकोड]] लुकअप सामान्यतः प्रत्येक संग्रहीत रिकॉर्ड के लिए हैमिंग दूरी की गणना करके कार्यान्वित किया जाता है।
* [[बिटबोर्ड]] प्रतिनिधित्व का उपयोग करने वाले [[कंप्यूटर शतरंज|कंप्यूटर चेस]] प्रोग्राम में, बिटबोर्ड का हैमिंग वेट खेल में शेष दिए गए प्रकार के टुकड़ों की संख्या, या खिलाड़ी के टुकड़ों द्वारा नियंत्रित बोर्ड के वर्गों की संख्या देता है, और इसलिए यह महत्वपूर्ण योगदान है किसी पद के मूल्य के लिए शब्द का उपयोग किया जाता है।
* हैमिंग वेट का उपयोग पहचान एफएफएस ffs(x) = pop(x ^ (x - 1)) का उपयोग करके पहले सेट को कुशलतापूर्वक खोजने के लिए किया जा सकता है। यह [[SPARC|स्पार्क]] जैसे प्लेटफ़ॉर्म पर उपयोगी है जिसमें हार्डवेयर हैमिंग वेट निर्देश हैं किन्तु कोई हार्डवेयर पहले सेट निर्देश नहीं खोजता है।<ref name="SPARC_1992" /><ref name="Warren_2013" />
*हैमिंग वेट ऑपरेशन की व्याख्या यूनरी अंक प्रणाली से [[बाइनरी संख्या]]ओं में रूपांतरण के रूप में की जा सकती है।<ref name="Blaxell_1978" />
*[[बिट सरणी]] और [[ तरंगिका वृक्ष |तरंगिका वृक्ष]] जैसी कुछ [[संक्षिप्त डेटा संरचना]]ओं के कार्यान्वयन में किया जाता है।

== कुशल कार्यान्वयन ==
क्रिप्टोग्राफी और अन्य अनुप्रयोगों में बिट सरणी की जनसंख्या गणना की अधिकांशतः आवश्यकता होती है। दो शब्दों a और b की हैमिंग दूरी की गणना a एक्स या b के हैमिंग वेट के रूप में की जा सकती है।<ref name="Warren_2013"/>

इसे कुशलतापूर्वक कैसे कार्यान्वित किया जाए इसकी समस्या का व्यापक अध्ययन किया गया है। इस प्रकार गणना के लिए एकल ऑपरेशन, या बिट वैक्टर पर समानांतर संचालन प्रोसेसर समर्थन हैं। जिन प्रोसेसरों में उन सुविधाओं की कमी है, उनके लिए ज्ञात सर्वोत्तम समाधान ट्री पैटर्न में गिनती जोड़ने पर आधारित हैं। उदाहरण के लिए, 16-बिट बाइनरी संख्या a = 0110 1100 1011 1010 में 1 बिट की संख्या गिनने के लिए, ये ऑपरेशन किए जा सकते हैं:

{| class="wikitable" style="text-align:center;"
! अभिव्यक्ति
! colspan=8 | बाइनरी
! दशमलव
! टिप्पणी
|-
| style="text-align:left;" | <code>a</code>
| 01
| 10
| 11
| 00
| 10
| 11
| 10
| 10
| style="text-align:left;"   {{n/a|27834}}
| style="text-align:left;" | मूल क्रमांक
|-
| style="text-align:left;" | <code>b0 = (a >> 0) & 01 01 01 01 01 01 01 01</code>
| 01
| 00
| 01
| 00
| 00
| 01
| 00
| 00
| style="text-align:left;" | 1, 0, 1, 0, 0, 1, 0, 0
| style="text-align:left;" | a से प्रत्येक अन्य बिट
|-
| style="text-align:left;" | <code>b1 = (a >> 1) & 01 01 01 01 01 01 01 01</code>
| 00
| 01
| 01
| 00
| 01
| 01
| 01
| 01
| style="text-align:left;" | 0, 1, 1, 0, 1, 1, 1, 1
| style="text-align:left;" | a से शेष बिट्स
|-
| style="text-align:left;" | <code>c = b0 + b1</code>
| 01
| 01
| 10
| 00
| 01
| 10
| 01
| 01
| style="text-align:left;" | 1, 1, 2, 0, 1, 2, 1, 1
| style="text-align:left;" | प्रत्येक 2-बिट स्लाइस में 1s की गिनती
|-
| style="text-align:left;" | <code>d0 = (c >> 0) & 0011 0011 0011 0011</code>
| colspan=2 | 0001
| colspan=2 | 0000
| colspan=2 | 0010
| colspan=2 | 0001
| style="text-align:left;" | 1, 0, 2, 1
| style="text-align:left;" | सी से हर दूसरी गिनती
|-
| style="text-align:left;" | <code>d2 = (c >> 2) & 0011 0011 0011 0011</code>
| colspan=2 | 0001
| colspan=2 | 0010
| colspan=2 | 0001
| colspan=2 | 0001
| style="text-align:left;" | 1, 2, 1, 1
| style="text-align:left;" | शेष की गणना c से की जाती है
|-
| style="text-align:left;" | <code>e = d0 + d2</code>
| colspan=2 | 0010
| colspan=2 | 0010
| colspan=2 | 0011
| colspan=2 | 0010
| style="text-align:left;" | 2, 2, 3, 2
| style="text-align:left;" | a के प्रत्येक 4-बिट स्लाइस में 1s की गिनती
|-
| style="text-align:left;" | <code>f0 = (e >> 0) & 00001111 00001111</code>
| colspan=4 | 00000010
| colspan=4 | 00000010
| style="text-align:left;" | 2, 2
| style="text-align:left;" | e से प्रत्येक अन्य गिनती
|-
| style="text-align:left;" | <code>f4 = (e >> 4) & 00001111 00001111</code>
| colspan=4 | 00000010
| colspan=4 | 00000011
| style="text-align:left;" | 2, 3
| style="text-align:left;" | शेष की गिनती e से होती है
|-
| style="text-align:left;" | <code>g = f0 + f4</code>
| colspan=4 | 00000100
| colspan=4 | 00000101
| style="text-align:left;" | 4, 5
| style="text-align:left;" | प्रत्येक 8-बिट स्लाइस में 1s की गिनती
|-
| style="text-align:left;" | <code>h0 = (g >> 0) & 0000000011111111</code>
| colspan=8 | 0000000000000101
| style="text-align:left;" | 5
| style="text-align:left;" | g से प्रत्येक अन्य गिनती
|-
| style="text-align:left;" | <code>h8 = (g >> 8) & 0000000011111111</code>
| colspan=8 | 0000000000000100
| style="text-align:left;" | 4
| style="text-align:left;" | शेष की गणना g से की जाती है
|-
| style="text-align:left;" | <code>i = h0 + h8</code>
| colspan=8 | 0000000000001001
| style="text-align:left;" | 9
| style="text-align:left;" | संपूर्ण 16-बिट शब्द में 1s की गिनती
|}
यहां, ऑपरेशन [[सी (प्रोग्रामिंग भाषा)]] के समान हैं {{code|X >> Y}} का अर्थ है X को Y बिट्स द्वारा दाईं ओर स्थानांतरित करना, X और Y का अर्थ है X और Y का बिटवाइज़, और + सामान्य जोड़ है। इस समस्या के लिए ज्ञात सर्वोत्तम एल्गोरिदम ऊपर चित्रित अवधारणा पर आधारित हैं और यहां दिए गए हैं:<ref name="Warren_2013"/>

<syntaxhighlight lang="c">
//types and constants used in the functions below
//uint64_t is an unsigned 64-bit integer variable type (defined in C99 version of C language)
const uint64_t m1  = 0x5555555555555555; //binary: 0101...
const uint64_t m2  = 0x3333333333333333; //binary: 00110011..
const uint64_t m4  = 0x0f0f0f0f0f0f0f0f; //binary:  4 zeros,  4 ones ...
const uint64_t m8  = 0x00ff00ff00ff00ff; //binary:  8 zeros,  8 ones ...
const uint64_t m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ...
const uint64_t m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones
const uint64_t h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3...

//This is a naive implementation, shown for comparison,
//and to help in understanding the better functions.
//This algorithm uses 24 arithmetic operations (shift, add, and).
int popcount64a(uint64_t x)
{
    x = (x & m1 ) + ((x >>  1) & m1 ); //put count of each  2 bits into those  2 bits 
    x = (x & m2 ) + ((x >>  2) & m2 ); //put count of each  4 bits into those  4 bits 
    x = (x & m4 ) + ((x >>  4) & m4 ); //put count of each  8 bits into those  8 bits 
    x = (x & m8 ) + ((x >>  8) & m8 ); //put count of each 16 bits into those 16 bits 
    x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits 
    x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits 
    return x;
}

//This uses fewer arithmetic operations than any other known  
//implementation on machines with slow multiplication.
//This algorithm uses 17 arithmetic operations.
int popcount64b(uint64_t x)
{
    x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
    x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 
    x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits 
    x += x >>  8;  //put count of each 16 bits into their lowest 8 bits
    x += x >> 16;  //put count of each 32 bits into their lowest 8 bits
    x += x >> 32;  //put count of each 64 bits into their lowest 8 bits
    return x & 0x7f;
}

//This uses fewer arithmetic operations than any other known  
//implementation on machines with fast multiplication.
//This algorithm uses 12 arithmetic operations, one of which is a multiply.
int popcount64c(uint64_t x)
{
    x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
    x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 
    x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits 
    return (x * h01) >> 56;  //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 
}
</syntaxhighlight>
उपरोक्त कार्यान्वयन में किसी भी ज्ञात एल्गोरिदम की तुलना में सबसे व्यर्थ स्थिति वाला व्यवहार है। चूँकि, जब किसी मान में कुछ गैर-शून्य बिट्स होने की अपेक्षा होती है, तो इसके अतिरिक्त एल्गोरिदम का उपयोग करना अधिक कुशल हो सकता है जो इन बिट्स को समय में गिनता है। जैसा कि वेगनर ने 1960 में वर्णित किया था,<ref name="Wegner_1960"/> x के साथ x का बिटवाइज़ AND - 1 केवल सबसे कम महत्वपूर्ण गैर-शून्य बिट को शून्य करने में x से भिन्न होता है: 1 घटाने से 0s की सबसे दाईं स्ट्रिंग को 1s में बदल दिया जाता है, और सबसे दाईं ओर 1 को 0 में बदल दिया जाता है। यदि x में मूल रूप से n बिट्स थे जो थे 1, तो इस ऑपरेशन के केवल n पुनरावृत्तियों के बाद, x शून्य हो जाता है। निम्नलिखित कार्यान्वयन इसी सिद्धांत पर आधारित है।

<syntaxhighlight lang="c">
//This is better when most bits in x are 0
//This algorithm works the same for all data sizes.
//This algorithm uses 3 arithmetic operations and 1 comparison/branch per "1" bit in x.
int popcount64d(uint64_t x)
{
    int count;
    for (count=0; x; count++)
        x &= x - 1;
    return count;
}
</syntaxhighlight>
यदि अधिक मेमोरी उपयोग की अनुमति है, जिससे हम उपरोक्त विधियों की तुलना में हैमिंग वेट की तेजी से गणना कर सकते हैं। असीमित मेमोरी के साथ, हम आसानी से प्रत्येक 64 बिट पूर्णांक के हैमिंग वेट की बड़ी लुकअप तालिका बना सकते हैं। यदि हम प्रत्येक 16 बिट पूर्णांक के हैमिंग फ़ंक्शन की लुकअप तालिका संग्रहीत कर सकते हैं, जिससे हम प्रत्येक 32 बिट पूर्णांक के हैमिंग वेट की गणना करने के लिए निम्नलिखित कार्य कर सकते हैं।
<syntaxhighlight lang="c">
static uint8_t wordbits[65536] = { /* bitcounts of integers 0 through 65535, inclusive */ };
//This algorithm uses 3 arithmetic operations and 2 memory reads.
int popcount32e(uint32_t x)
{
    return wordbits[x & 0xFFFF] + wordbits[x >> 16];
}
</syntaxhighlight>

<syntaxhighlight lang="c">
//Optionally, the wordbits[] table could be filled using this function
int popcount32e_init(void)
{
    uint32_t i;
    uint16_t x;
    int count;
    for (i=0; i <= 0xFFFF; i++)
    {
        x = i;
        for (count=0; x; count++) // borrowed from popcount64d() above
            x &= x - 1;
        wordbits[i] = count;
    }
}
</syntaxhighlight>
मुला एट अल.<ref name="Mula_2018"/> दिखाया गया है कि पॉपकाउंट 64b का वेक्टरकृत संस्करण समर्पित निर्देशों (उदाहरण के लिए, x64 प्रोसेसर पर पॉपसीएनटी) की तुलना में तेजी से चल सकता है।

==न्यूनतम वेट==
[[त्रुटि-सुधार कोड]] या त्रुटि-सुधार कोडिंग में, न्यूनतम हैमिंग वेट, जिसे सामान्यतः न्यूनतम वेट ''w<sub>min</sub>'' कहा जाता है कोड का वेट सबसे कम वेट वाले गैर-शून्य कोड शब्द का होता है। किसी कोड शब्द का भार w शब्द में 1s की संख्या है। उदाहरण के लिए, शब्द 11001010 का भार 4 है।

एक [[रैखिक ब्लॉक कोड]] में न्यूनतम वेट भी [[न्यूनतम हैमिंग दूरी]] (d<sub>min</sub>) है और कोड की त्रुटि सुधार क्षमता को परिभाषित करता है। यदि w<sub>min</sub>= n, फिर d<sub>min</sub>= n और कोड d<sub>min</sub>/2 त्रुटियाँ तक सही हो जाता है.<ref>Stern & Mahmoud, ''Communications System Design'', [[Prentice Hall]], 2004, p&nbsp;477ff.</ref>
== भाषा समर्थन ==
कुछ सी कंपाइलर आंतरिक कार्य प्रदान करते हैं जो बिट गिनती की सुविधा प्रदान करते हैं। उदाहरण के लिए, [[जीएनयू कंपाइलर संग्रह]] (अप्रैल 2004 में संस्करण 3.4 से) में अंतर्निहित फ़ंक्शन सम्मिलित है <code>__builtin_popcount</code> यदि उपलब्ध हो तो यह प्रोसेसर निर्देश का उपयोग करेगा या अन्यथा कुशल लाइब्रेरी कार्यान्वयन का उपयोग करता है।<ref name="GCC"/> [[एलएलवीएम]] या एलएलवीएम-जीसीसी ने जून 2005 में संस्करण 1.5 से इस फ़ंक्शन को सम्मिलित किया है।<ref name="LLVM"/>

C++ मानक लाइब्रेरी में, बिट-सरणी डेटा संरचना <code>bitset</code> <code>count()</code> वह विधि जो सेट किए गए बिट्स की संख्या को गिनती है। [[C++20]] में, नया हेडर <code><bit></code> फ़ंक्शंस युक्त, जोड़ा गया था <code>std::popcount</code> और <code>std::has_single_bit</code>, अहस्ताक्षरित पूर्णांक प्रकारों के तर्क लेता है।

जावा में, बढ़ने योग्य बिट-सरणी डेटा संरचना {{Javadoc:SE|java/util|BitSet}} {{Javadoc:SE|java/util|BitSet|cardinality()}} विधि जो सेट किए गए बिट्स की संख्या की गणना करती है। इसके अतिरिक्त, वहाँ हैं {{Javadoc:SE|java/lang|Integer|bitCount(int)}} और {{Javadoc:SE|java/lang|Long|bitCount(long)}} क्रमशः मौलिक 32-बिट और 64-बिट पूर्णांकों में बिट्स की गिनती करने का कार्य करता है। यह भी {{Javadoc:SE|java/math|BigInteger}} मनमाना-परिशुद्धता पूर्णांक वर्ग में भी है {{Javadoc:SE|java/math|BigInteger|bitCount()}} विधि जो बिट्स की गिनती करती है।

[[पायथन (प्रोग्रामिंग भाषा)]] में, <code>int</code> प्रकार में है <code>bit_count()</code> सेट बिट्स की संख्या गिनने की विधि यह कार्यक्षमता अक्टूबर 2021 में जारी पायथन 3.10 में प्रस्तुत की गई थी।<ref>{{cite web |title=What's New In Python 3.10 |url=https://docs.python.org/3.10/whatsnew/3.10.html |website=python.org}}</ref>[[ सामान्य लिस्प | सामान्य लिस्प]] में, फ़ंक्शन <code>logcount</code>, गैर-ऋणात्मक पूर्णांक दिया गया है, इस प्रकार 1 बिट्स की संख्या लौटाता है। (ऋणात्मक पूर्णांकों के लिए यह 2 के पूरक संकेतन में 0 बिट्स की संख्या लौटाता है।) किसी भी स्थिति में पूर्णांक बिग्नम हो सकता है।

[[ग्लासगो हास्केल कंपाइलर]] 7.4 से प्रारंभ होकर, [[हास्केल (प्रोग्रामिंग भाषा)]] बेस पैकेज में है <code>popCount</code> फ़ंक्शन सभी प्रकार के उदाहरणों पर उपलब्ध है <code>Bits</code> कक्षा (से उपलब्ध है <code>Data.Bits</code> मापांक)।<ref name="GHC"/>

[[SQL|एसक्यूएल]] भाषा का [[MySQL|मायएसक्यूएल]] संस्करण प्रदान करता है <code>BIT_COUNT()</code> मानक फ़ंक्शन के रूप में।<ref name="MySQL_50"/>

[[फोरट्रान 2008]] में मानक, आंतरिक, मौलिक कार्य है <code>popcnt</code> पूर्णांक (या पूर्णांक सरणी) के अन्दर गैर-शून्य बिट्स की संख्या वापस करता है।<ref name="Metcalf_2011"/>

कुछ प्रोग्रामयोग्य वैज्ञानिक पॉकेट कैलकुलेटर सेट बिट्स की संख्या की गणना करने के लिए विशेष कमांड की सुविधा देते हैं, उदाहरण के लिए <code>#B</code> [[HP-16C|एचपी-16सी]] पर <ref name="HP-16C_1982"/><ref name="Schwartz_Grevelle_2003"/> और WP 43S,<ref name="Bonin_2019_OG"/><ref name="Bonin_2019_RG"/> <code>#BITS</code><ref name="Martin_McClure_2015"/><ref name="Martin_2015"/>या <code>BITSUM</code> <ref name="Thörngren_2017"/><ref name="Thörngren_2017_2"/> एचपी-16सी एमुलेटर पर, और <code>nBITS</code> WP 34S पर होता है.<ref name="Bonin_2012"/><ref name="Bonin_2015"/>

[[फ्रीपास्कल]] संस्करण 3.0 से पॉपसीएनटी प्रयुक्त करता है।<ref name="FPC docs"/>
== प्रोसेसर समर्थन ==
* 1960 के दशक में [[IBM STRETCH|आईबीएम स्ट्रेच]] कंप्यूटर ने सभी तार्किक परिचालनों के उप-उत्पाद के रूप में सेट बिट्स की संख्या के साथ-साथ अग्रणी शून्य की संख्या की गणना की थी।<ref name="Warren_2013"/>
*[[क्रे]] सुपरकंप्यूटर में प्रारंभ में जनसंख्या गणना [[मशीन अनुदेश]] प्रदर्शित किया गया था, ऐसी अफवाह थी कि [[क्रिप्ट विश्लेषण]] अनुप्रयोगों के लिए अमेरिकी सरकार की [[राष्ट्रीय सुरक्षा एजेंसी]] द्वारा विशेष रूप से अनुरोध किया गया था।<ref name="Warren_2013" />
* [[नियंत्रण डेटा निगम]] (सीडीसी) की [[सीडीसी 6000 श्रृंखला]] और सीडीसी साइबर या साइबर 70/170 श्रृंखला की मशीनों में जनसंख्या गणना निर्देश सम्मिलित हैं; 60-बिट मशीनों के लिए कम्पास में, इस निर्देश को इस प्रकार <code>CXi</code>. कोडित किया गया था 
* 64-बिट स्पार्क संस्करण 9 आर्किटेक्चर परिभाषित करता है <code>POPC</code> निर्देश,<ref name="SPARC_1992" /><ref name="Warren_2013" /> किन्तु अधिकांश कार्यान्वयन इसे प्रयुक्त नहीं करते हैं, जिसके लिए ऑपरेटिंग सिस्टम द्वारा इसका अनुकरण करना आवश्यक होता है।<ref name="JDK_BitCount" />
*[[डोनाल्ड नुथ]] का मॉडल कंप्यूटर <nowiki>[[एमएमआईएक्स]]</nowiki> जो अपनी पुस्तक [[कंप्यूटर प्रोग्रामिंग की कला]] में एमआएक्स का स्थान लेने जा रहा है, उसमें है <code>SADD</code> 1999 से निर्देश <code>SADD a,b,c</code> सभी बिट्स को गिनता है जो b में 1 और c में 0 हैं और परिणाम को a में लिखता है।
* 1999 में जारी [[कॉम्पैक]] का अल्फा 21264A, पहला अल्फा श्रृंखला सीपीयू डिज़ाइन था जिसमें काउंट एक्सटेंशन था (<code>CIX</code>).
* [[एनालॉग डिवाइस]] के [[ Blackfin |ब्लैकफ़िन]] प्रोसेसर की सुविधा है <code>ONES</code> 32-बिट जनसंख्या गणना करने का निर्देश होता है।<ref name="AD_2001"/>
*[[AMD|एएमडी]] के [[AMD K10|एएमडी K10]] आर्किटेक्चर ने उन्नत बिट मैनिपुलेशन (एबीएम) [[ निर्देश समुच्चय |निर्देश समुच्चय]] की प्रारंभ की <code>POPCNT</code> 2007 में [[SSE4a|एसएसई4ए]] एक्सटेंशन के भाग के रूप में निर्देश का उपयोग किया है।
* [[ इण्टेल कोर | इण्टेल कोर]] प्रोसेसर प्रस्तुत किया गया <code>POPCNT</code> एसएसई4.2 इंस्ट्रक्शन सेट एक्सटेंशन के साथ निर्देश, पहली बार नेहलेम (माइक्रोआर्किटेक्चर)-आधारित [[कोर i7]] प्रोसेसर में उपलब्ध है, जो नवंबर 2008 में जारी किया गया था।
* [[एआरएम वास्तुकला|एआरएम आर्किटेक्चर]] की प्रारंभ की गई <code>VCNT</code> [[एआरएम एडवांस्ड SIMD|एआरएम एडवांस्ड सिमड]] (नियोन (निर्देश सेट) एक्सटेंशन के भाग के रूप में निर्देश का उपयोग किया जाता है।
* [[ RISC-वी | आरआईएससी-वी]] आर्किटेक्चर की प्रारंभ की गई <code>PCNT</code> बिट मैनिपुलेशन (b) एक्सटेंशन के भाग के रूप में निर्देश का उपयोग किया जाता है।<ref name="RISC-V-B" />
== यह भी देखें ==
* दो पूरक
* [[प्रशंसक बाहर|फैन आउट]]

==संदर्भ                                                                                                                                                                                                                                        ==
{{Reflist|refs=
<ref name="CLNZ">{{cite conference
 | last1 = Cohen | first1 = Gérard D. | author1-link = Gérard Denis Cohen
 | last2 = Lobstein | first2 = Antoine
 | last3 = Naccache | first3 = David
 | last4 = Zémor | first4 = Gilles
 | editor-last = Nyberg | editor-first = Kaisa
 | contribution = How to improve an exponentiation black-box
 | doi = 10.1007/BFb0054128
 | pages = 211–220
 | publisher = Springer
 | series = Lecture Notes in Computer Science
 | title = Advances in Cryptology – EUROCRYPT '98, International Conference on the Theory and Application of Cryptographic Techniques, Espoo, Finland, May 31 – June 4, 1998, Proceeding
 | volume = 1403
 | year = 1998| doi-access = free
 }}</ref>
<ref name="Rosetta_1">[https://wiki.formulae.org/Population_count], written in Fōrmulæ. ''The Fōrmulæ wiki''. Retrieved 2019-09-30.</ref>
<ref name="Rosetta_2">A solution to the task [http://rosettacode.org/wiki/Population_count Population count]. Retrieved 2019-09-30.</ref>
<ref name="Rosetta_3">[http://www.rosettacode.org/wiki/Rosetta_Code Rosetta Code]. Retrieved 2019-09-30.</ref>
<ref name="Knuth_2009">{{cite book |author-first=Donald Ervin |author-last=Knuth |author-link=Donald Ervin Knuth |title=The Art of Computer Programming |title-link=The Art of Computer Programming |volume=4, Fascicle 1 |chapter=Bitwise tricks & techniques; Binary Decision Diagrams |publisher=[[Addison–Wesley Professional]] |isbn=978-0-321-58050-4 |date=2009}} (NB. Draft of [http://www-cs-faculty.stanford.edu/~knuth/fasc1b.ps.gz Fascicle 1b] available for download.)</ref>
<ref name="Warren_2013">{{cite book |title=Hacker's Delight |title-link=Hacker's Delight |author-first=Henry S. |author-last=Warren Jr. |date=2013 |orig-year=2002 |edition=2 |publisher=[[Addison Wesley]] - [[Pearson Education, Inc.]] |isbn=978-0-321-84268-8 |id=0-321-84268-5 |pages=81–96}}</ref>
<ref name="Stoica_2003">{{cite journal |author-last1=Stoica |author-first1=I. |author-last2=Morris |author-first2=R. |author-last3=Liben-Nowell |author-first3=D. |author-last4=Karger |author-first4=D. R. |author-last5=Kaashoek |author-first5=M. F. |author-last6=Dabek |author-first6=F. |author-last7=Balakrishnan |author-first7=H. |title=Chord: a scalable peer-to-peer lookup protocol for internet applications |journal=[[IEEE/ACM Transactions on Networking]] |volume=11 |issue=1 |date=February 2003 |pages=17–32 |doi=10.1109/TNET.2002.808407 |s2cid=221276912 |quote=Section 6.3: "In general, the number of fingers we need to follow will be the number of ones in the binary representation of the distance from node to query."}}</ref>
<ref name="Blaxell_1978">{{cite journal |author-last=Blaxell |author-first=David |editor-last1=Hogben |editor-first1=David |editor-last2=Fife |editor-first2=Dennis W. |title=Record linkage by bit pattern matching |pages=146–156 |publisher=[[U.S. Department of Commerce]] / [[National Bureau of Standards]] |series=NBS Special Publication |journal=Computer Science and Statistics--Tenth Annual Symposium on the Interface |url=https://books.google.com/books?id=-MrJPUqTPh8C&pg=PA146 |volume=503 |date=1978}}</ref>
<ref name="Wegner_1960">{{cite journal |author-last=Wegner |author-first=Peter <!-- A.? according to Hacker's Delight --> |author-link=Peter Wegner |doi=10.1145/367236.367286 |issue=5 |journal=[[Communications of the ACM]] |page=322 |title=A technique for counting ones in a binary computer |volume=3 |date=May 1960|s2cid=31683715 }}</ref>
<ref name="GCC">{{cite web |url=https://gcc.gnu.org/gcc-3.4/changes.html |title=GCC 3.4 Release Notes |work=GNU Project}}</ref>
<ref name="LLVM">{{cite web |url=http://llvm.org/releases/1.5/docs/ReleaseNotes.html |title=LLVM 1.5 Release Notes |work=LLVM Project}}</ref>
<ref name="Glaisher_1899">{{cite journal |author-last=Glaisher |author-first=James Whitbread Lee |author-link=James Whitbread Lee Glaisher |journal=[[The Quarterly Journal of Pure and Applied Mathematics]] |pages=150–156 |title=On the residue of a binomial-theorem coefficient with respect to a prime modulus |url=https://books.google.com/books?id=j7sKAAAAIAAJ&pg=PA150 |volume=30 |date=1899}} (NB. See in particular the final paragraph of p.&nbsp;156.)</ref>
<ref name="Thompson_1983">{{cite book |author-first=Thomas M. |author-last=Thompson |title=From Error-Correcting Codes through Sphere Packings to Simple Groups |publisher=[[The Mathematical Association of America]] |series=The Carus Mathematical Monographs #21 |date=1983 |page=33}}</ref>
<ref name="Reed_1954">{{cite journal |author-first=Irving Stoy |author-last=Reed |author-link=Irving Stoy Reed |title=A Class of Multiple-Error-Correcting Codes and the Decoding Scheme |journal=[[IRE Professional Group on Information Theory]] |publisher=[[Institute of Radio Engineers]] (IRE) |volume=PGIT-4 |date=1954 |pages=38–49}}</ref>
<ref name="GHC">{{cite web |url=http://www.haskell.org/ghc/docs/7.4-latest/html/users_guide/release-7-4-1.html#id527862 |title=GHC 7.4.1 release notes}} GHC documentation.</ref>
<ref name="MySQL_50">{{cite web |url=https://dev.mysql.com/doc/refman/5.0/en/bit-functions.html |title=Chapter 12.11. Bit Functions — MySQL 5.0 Reference Manual}}</ref>
<ref name="Metcalf_2011">{{cite book |author-first1=Michael |author-last1=Metcalf |author-first2=John |author-last2=Reid |author-first3=Malcolm |author-last3=Cohen |date=2011 |title=Modern Fortran Explained |publisher=[[Oxford University Press]] |isbn=978-0-19-960142-4 |page=380}}</ref>
<ref name="SPARC_1992">{{cite book |author=SPARC International, Inc. |title=The SPARC architecture manual: version 8 |date=1992 |publisher=[[Prentice Hall]] |location=Englewood Cliffs, New Jersey, USA |isbn=0-13-825001-4 |pages=[https://archive.org/details/sparcarchitectur00spar/page/231 231] |chapter-url=https://archive.org/details/sparcarchitectur00spar/page/231 |edition=Version 8 |chapter=A.41: Population Count. Programming Note |chapter-url-access=registration}}</ref>
<ref name="HP-16C_1982">{{cite book |title=Hewlett-Packard HP-16C Computer Scientist Owner's Handbook |publisher=[[Hewlett-Packard Company]] |date=April 1982 |id=00016-90001 |url=http://www.hp41.net/forum/fileshp41net/hp16c.pdf<!-- https://www.scss.tcd.ie/SCSSTreasuresCatalog/hardware/TCD-SCSS-T.20160121.004/HP16C-OwnersHandbook.pdf --> |access-date=2017-03-28 |url-status=live |archive-url=https://web.archive.org/web/20170328204119/http://www.hp41.net/forum/fileshp41net/hp16c.pdf<!-- https://web.archive.org/web/20170328201815/https://www.scss.tcd.ie/SCSSTreasuresCatalog/hardware/TCD-SCSS-T.20160121.004/HP16C-OwnersHandbook.pdf --> |archive-date=2017-03-28}}</ref>
<ref name="Schwartz_Grevelle_2003">{{cite book |title=HP16C Emulator Library for the HP48S/SX |author-first1=Jake |author-last1=Schwartz |author-first2=Rick |author-last2=Grevelle |date=2003-10-20 |orig-year=1993<!-- 1993-04 --> |edition=1 |version=1.20 |url=http://www.pahhc.org/mul8r.htm |access-date=2015-08-15}} (NB. This library also works on the [[HP 48G]]/[[HP 48GX|GX]]/[[HP 48G+|G+]]. Beyond the feature set of the [[HP-16C]] this package also supports calculations for binary, octal, and hexadecimal [[floating-point number]]s in [[scientific notation]] in addition to the usual decimal floating-point numbers.)</ref>
<ref name="Martin_McClure_2015">{{cite web |title=HP16C Emulator Module for the HP-41CX - User's Manual and QRG |author-first1=Ángel M. |author-last1=Martin |author-first2=Greg J. |author-last2=McClure |date=2015-09-05 |url=http://systemyde.com/pdf/HP_16C_Emulator_Manual.pdf |access-date=2017-04-27 |url-status=live |archive-url=https://web.archive.org/web/20170427204416/http://systemyde.com/pdf/HP_16C_Emulator_Manual.pdf |archive-date=2017-04-27}} (NB. Beyond the [[HP-16C]] feature set this custom library for the [[HP-41CX]] extends the functionality of the calculator by about 50 additional functions.)</ref>
<ref name="Martin_2015">{{cite web |title=HP-41: New HP-16C Emulator available |author-first=Ángel M. |author-last=Martin |date=2015-09-07 |url=http://www.hpmuseum.org/forum/thread-4663.html |access-date=2017-04-27 |url-status=live |archive-url=https://web.archive.org/web/20170427204721/http://www.hpmuseum.org/forum/thread-4663.html |archive-date=2017-04-27}}</ref>
<ref name="Thörngren_2017">{{cite web |author-first=Håkan |author-last=Thörngren |title=Ladybug Documentation |edition=release 0A |date=2017-01-10 |url=http://www.hpmuseum.org/forum/attachment.php?aid=4350 |access-date=2017-01-29}} [http://www.hpmuseum.org/forum/attachment.php?aid=4349]</ref>
<ref name="Thörngren_2017_2">{{cite web |title=New HP-41 module available: Ladybug |date=2017-01-10 |url=http://www.hpmuseum.org/forum/thread-7545.html |access-date=2017-01-29 |url-status=live |archive-url=https://web.archive.org/web/20170129182549/http://www.hpmuseum.org/forum/thread-7545.html |archive-date=2017-01-29}}</ref>
<ref name="Bonin_2012">{{cite web |author-first1=Paul |author-last1=Dale |author-first2=Walter |author-last2=Bonin |edition=3.1 |title=WP 34S Owner's Manual |date=2012 |orig-year=2008 |url=https://freefr.dl.sourceforge.net/project/wp34s/doc/Manual_wp_34s_3_1.pdf |access-date=2017-04-27}}</ref>
<ref name="Bonin_2015">{{cite book |author-first=Walter |author-last=Bonin |edition=3.3 |title=WP 34S Owner's Manual |date=2015 |orig-year=2008 |isbn=978-1-5078-9107-0}}</ref>
<ref name="AD_2001">{{cite book |title=Blackfin Instruction Set Reference |date=2001 |publisher=[[Analog Devices]] |edition=Preliminary |pages=8–24 |id=Part Number 82-000410-14}}</ref> 
<ref name="Mula_2018">{{cite journal |author-last1=Muła |author-first1=Wojciech |author-last2=Kurz |author-first2=Nathan |author-last3=Lemire |author-first3=Daniel |title=Faster Population Counts Using AVX2 Instructions |journal=[[Computer Journal]] |volume=61 |issue=1| date=January 2018 |pages=111–120 |doi=10.1093/comjnl/bxx046 |arxiv=1611.07612|s2cid=540973 }}</ref>
<ref name="Bonin_2019_OG">{{cite book |title=WP&nbsp;43S Owner's Manual |date=2019 |orig-year=2015 |author-last=Bonin |author-first=Walter |isbn=978-1-72950098-9 |edition=draft |version=0.12 |page=135 |url=https://gitlab.com/Over_score/wp43s/raw/master/draft%20documentation/Owner_wp_43s_0_12s.pdf?inline=false |access-date=2019-08-05 }} [https://gitlab.com/Over_score/wp43s] [https://sourceforge.net/projects/wp43s/] (314 pages)</ref>
<ref name="Bonin_2019_RG">{{cite book |title=WP&nbsp;43S Reference Manual |date=2019 |orig-year=2015 |author-last=Bonin |author-first=Walter |isbn=978-1-72950106-1 |edition=draft |version=0.12 |pages=xiii, 104, 115, 120, 188 |url=https://gitlab.com/Over_score/wp43s/raw/master/draft%20documentation/Reference_wp_43s_0_12s.pdf?inline=false |access-date=2019-08-05 }} [https://gitlab.com/Over_score/wp43s] [https://sourceforge.net/projects/wp43s/] (271 pages)</ref>
<ref name="FPC docs">{{cite web |title=Free Pascal documentation popcnt |url=https://www.freepascal.org/docs-html/rtl/system/popcnt.html |access-date=2019-12-07 }}</ref>
<ref name="JDK_BitCount">{{cite web |title=JDK-6378821: bitCount() should use POPC on SPARC processors and AMD+10h |date=2006-01-30 |website=Java bug database |url=https://bugs.java.com/bugdatabase/view_bug.do?bug_id=6378821}}</ref>
<ref name="RISC-V-B">{{cite web |title=RISC-V "B" Bit Manipulation Extension for RISC-V, Draft v0.37 |date=2019-03-22 |author-last=Wolf |author-first=Claire |website=Github |url=https://github.com/riscv/riscv-bitmanip/blob/master/bitmanip-draft.pdf}}</ref>
}}
==अग्रिम पठन==
* {{cite book |title=HAKMEM |title-link=HAKMEM |author-first1=Michael |author-last1=Beeler |author-first2=Ralph William |author-last2=Gosper |author-link2=Bill Gosper |author-first3=Richard C. |author-last3=Schroeppel |author-link3=Richard C. Schroeppel |contribution=compilation |contributor-first1=Richard C. |contributor-last1=Schroeppel |contributor-link1=Richard C. Schroeppel |contributor-last2=Orman |contributor-first2=Hilarie K. |date=1972-02-29 |publisher=[[MIT AI Lab|Artificial Intelligence Laboratory]], [[Massachusetts Institute of Technology]], Cambridge, Massachusetts, USA |id=MIT AI Memo 239 |type=report}} ([http://www.inwap.com/pdp10/hbaker/hakmem/hacks.html#item169 Item 169]: Population count assembly code for the PDP/6-10.)
==बाहरी संबंध==
* [http://aggregate.ee.engr.uky.edu/MAGIC/#Population%20Count%20(Ones%20Count) Aggregate Magic Algorithms]. Optimized population count and other algorithms explained with sample code.
* [http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetNaive Bit Twiddling Hacks] Several algorithms with code for counting bits set.
* [http://www.necessaryandsufficient.net/2009/04/optimising-bit-counting-using-iterative-data-driven-development Necessary and Sufficient] - by Damien Wintour - Has code in C# for various Hamming Weight implementations.
* [https://stackoverflow.com/questions/109023/best-algorithm-to-count-the-number-of-set-bits-in-a-32-bit-integer/ Best algorithm to count the number of set bits in a 32-bit integer?] - Stackoverflow

{{DEFAULTSORT:Hamming Weight}}

[[Category:CS1|Hamming Weight]]
[[Category:Created On 10/07/2023|Hamming Weight]]
[[Category:Lua-based templates|Hamming Weight]]
[[Category:Machine Translated Page|Hamming Weight]]
[[Category:Pages with reference errors|Hamming Weight]]
[[Category:Pages with script errors|Hamming Weight]]
[[Category:Short description with empty Wikidata description|Hamming Weight]]
[[Category:Template documentation pages|Short description/doc]]
[[Category:Templates Vigyan Ready|Hamming Weight]]
[[Category:Templates that add a tracking category|Hamming Weight]]
[[Category:Templates that generate short descriptions|Hamming Weight]]
[[Category:Templates using TemplateData|Hamming Weight]]