चक्रीय अतिरेक जांच की गणना: Difference between revisions

Revision as of 22:31, 2 August 2023

साइक्लिक रिडंडेंसी जांच की कंप्यूटिंग पॉलीनोमियल डिवीज़न , मोडुलो टू के गणित से ली गई है। व्यवहार में, यह बाइनरी कोड मेसेज स्ट्रिंग के लॉन्ग डिवीज़न जैसा दिखता है, जिसमें जेनरेटर पॉलीनोमियल स्ट्रिंग द्वारा निश्चित संख्या में शून्य जोड़े जाते हैं, अतिरिक्त इसके कि एकमात्र ऑपरेशन रिप्लेस का स्थान लेते हैं। इस प्रकार का डिवीज़न एक संशोधित शिफ्ट का रजिस्टर द्वारा हार्डवेयर में कुशलतापूर्वक किया जाता है,^[1] और सॉफ्टवेयर में समतुल्य एल्गोरिदम की एक श्रृंखला द्वारा, बाइट-वाइज पॅरेललिज्म और स्पेस-टाइम ट्रेडऑफ़ के माध्यम से गणित के समीप सरल कोड से प्रारम्भ होता है और बाइट के माध्यम से शीघ्र (और निश्चित रूप से अधिक अस्पष्ट कोड) होता जाता है।^[2]

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

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

विभिन्न सीआरसी मानक एक प्रारंभिक शिफ्ट रजिस्टर मान, एक अंतिम एक्सक्लूसिव-या स्टेप और, सबसे गंभीर रूप से, थोड़ा ऑर्डरिंग (अंतहीनता) निर्दिष्ट करके पॉलीनोमियल डिवीज़न एल्गोरिदम का विस्तार करते हैं। परिणामस्वरूप, व्यवहार में देखा जाने वाला कोड प्योर डिवीज़न से कंफ्यूज रूप से भटक जाता है,^[2]और रजिस्टर बाएँ या दाएँ शिफ्ट हो सकता है।

उदाहरण

हार्डवेयर में पॉलीनोमियल डिवीज़न को प्रयुक्त करने के एक उदाहरण के रूप में, मान लीजिए कि हम ASCII वर्ण W से बने 8-बिट मेसेज के 8-बिट सीआरसी की कंप्यूटिंग करने का प्रयास कर रहे हैं, जो बाइनरी 01010111 है, डेसिमल 87₁₀, या हेक्साडेसिमल 57₁₆ होता है। उदाहरण के लिए, हम सीआरसी-8-ATM (HEC) पोल्य्नोमिअल $x^{8}+x^{2}+x+1$ का उपयोग करेंगे। ट्रांसमिटेड पहली बिट ट्रांसमिट(उच्चतम पॉवर का गुणांक $x$ ) बाईं ओर, यह 9-बिट स्ट्रिंग 100000111 के समरूप होता है।

बाइट मान 57₁₆ उपयोग किए गए बिट ऑर्डरिंग कन्वेंशन के आधार पर, दो अलग-अलग ऑर्डर में प्रसारित किया जा सकता है। प्रत्येक एक अलग मेसेज पॉलीनोमियल $M(x)$ उत्पन्न करता है। एमएसबिट-फर्स्ट, यह $x^{6}+x^{4}+x^{2}+x+1$ = 01010111 होता है, जबकि एलएसबिट-फर्स्ट, यह $x^{7}+x^{6}+x^{5}+x^{3}+x$ = 11101010 होता है। दो 16-बिट मेसेज पॉलीनोमियल $x^{8}M(x)$ बनाने के लिए इन्हे $x^{8}$ से गुणा किया जा सकता है।

फिर रेमैंडरफल की कंप्यूटिंग में जेनरेटर पॉलीनोमियल $G(x)$ के गुणजों को सब्सट्रैक्ट करना सम्मिलित होता है। यह सम्पूर्ण रूप में दशमलव लॉन्ग डिवीज़न के अनुरूप होता है, परन्तु इससे सरल होता है क्योंकि प्रत्येक स्टेप में एकमात्र संभावित गुणज 0 और 1 होते हैं, और ऊपरी अंकों को कम करने के अतिरिक्त सबस्ट्रक्शन इनफिनिटी से बोर्रो किया जाता है। चूँकि हमें भागफल की केयर नहीं है, इसलिए इसे रिकॉर्ड करने की कोई आवश्यकता नहीं होती है।

Most-significant bit फर्स्ट

Least-significant bit फर्स्ट

	0	1	0	1	0	1	1	1	0	0	0	0	0	0	0	0
−	0	0	0	0	0	0	0	0	0
=	0	1	0	1	0	1	1	1	0	0	0	0	0	0	0	0
	−	1	0	0	0	0	0	1	1	1
=	0	0	0	1	0	1	1	0	1	1	0	0	0	0	0	0
		−	0	0	0	0	0	0	0	0	0
=	0	0	0	1	0	1	1	0	1	1	0	0	0	0	0	0
			−	1	0	0	0	0	0	1	1	1
=	0	0	0	0	0	1	1	0	1	0	1	1	0	0	0	0
				−	0	0	0	0	0	0	0	0	0
=	0	0	0	0	0	1	1	0	1	0	1	1	0	0	0	0
					−	1	0	0	0	0	0	1	1	1
=	0	0	0	0	0	0	1	0	1	0	1	0	1	1	0	0
						−	1	0	0	0	0	0	1	1	1
=	0	0	0	0	0	0	0	0	1	0	1	0	0	0	1	0
							−	0	0	0	0	0	0	0	0	0
=	0	0	0	0	0	0	0	0	1	0	1	0	0	0	1	0

	1	1	1	0	1	0	1	0	0	0	0	0	0	0	0	0
−	1	0	0	0	0	0	1	1	1
=	0	1	1	0	1	0	0	1	1	0	0	0	0	0	0	0
	−	1	0	0	0	0	0	1	1	1
=	0	0	1	0	1	0	0	0	0	1	0	0	0	0	0	0
		−	1	0	0	0	0	0	1	1	1
=	0	0	0	0	1	0	0	0	1	0	1	0	0	0	0	0
			−	0	0	0	0	0	0	0	0	0
=	0	0	0	0	1	0	0	0	1	0	1	0	0	0	0	0
				−	1	0	0	0	0	0	1	1	1
=	0	0	0	0	0	0	0	0	1	0	0	1	1	0	0	0
					−	0	0	0	0	0	0	0	0	0
=	0	0	0	0	0	0	0	0	1	0	0	1	1	0	0	0
						−	0	0	0	0	0	0	0	0	0
=	0	0	0	0	0	0	0	0	1	0	0	1	1	0	0	0
							−	0	0	0	0	0	0	0	0	0
=	0	0	0	0	0	0	0	0	1	0	0	1	1	0	0	0

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

एमएसबिट-फर्स्ट उदाहरण में, रेमैंडर पॉलीनोमियल $x^{7}+x^{5}+x$ होता है। हेक्साडेसिमल संख्या को कनवर्ट करने के लिए कन्वेंशन का उपयोग किया जाता है जो x की उच्चतम पॉवर एमएसबिट होता है; यह A2₁₆ होता है। एलएसबिट-फर्स्ट में रेमैंडरफल $x^{7}+x^{4}+x^{3}$ होता है। हेक्साडेसिमल संख्या को कनवर्ट करने के लिए कन्वेंशन का उपयोग किया जाता है जो x की उच्चतम पॉवर एलएसबिट होता है; यह 19₁₆ होता है।

इम्प्लीमेंटेशन

प्रत्येक स्टेप पर पूरा मेसेज लिखना, जैसा कि ऊपर दिए गए उदाहरण में किया गया है, बहुत कठिन होता है। मात्र इंटररेस्टिंग बिट्स को रखने के लिए कुशल इम्प्लीमेंटेशन $n$ -बिट शिफ्ट रजिस्टर का उपयोग करता है। पॉलीनोमियल का $x$ से गुणा किया जाता है जो रजिस्टर को एक स्थान से स्थानांतरित करने के समान होता है, क्योंकि गुणांक मूल्य में नहीं बदलते हैं बल्कि मात्र पॉलीनोमियल के अगले पद तक बढ़ते हैं।

यहां एन-बिट सीआरसी की कंप्यूटिंग के लिए कुछ स्यूडोकोड का फर्स्ट ड्राफ्ट होता है। यह पॉलीनोमियलों के लिए एक काल्पनिक वस्तु संरचना का उपयोग करता है, जहाँ x एक पूर्णांक चर नहीं होता है, तथापि एक कंस्ट्रक्टर एक पॉलीनोमियल ऑब्जेक्ट उत्पन्न करता है जिसे जोड़ा, गुणा और घातांकित किया जा सकता है। xor के लिए दो पॉलीनोमियलों को जोड़ा जाता है, मॉड्यूलो दो; अर्थात्, दोनों पॉलीनोमियलों से प्रत्येक मिलान पद के गुणांकों को अलग किया जाता है।

function crc(bit array bitString[1..len], int len) {
    remainderPolynomial := 0
    // A popular variant complements remainderPolynomial here; see § Preset to −1 below
    for i from 1 to len {
        remainderPolynomial := remainderPolynomial xor (bitstring[i] * xⁿ⁻¹)
        if (coefficient of xⁿ⁻¹ of remainderPolynomial) = 1 {
            remainderPolynomial := (remainderPolynomial * x) xor generatorPolynomial
        } else {
            remainderPolynomial := (remainderPolynomial * x)
        }
    }
    // A popular variant complements remainderPolynomial here; see § Post-invert below
    return remainderPolynomial

}

कोड फ्रेगमेंट 1: सरल पॉलीनोमियल डिवीज़न

ध्यान दें कि यह उदाहरण कोड बाइट्स का उपयोग न करके बिट-ऑर्डरिंग कन्वेंशन को निर्दिष्ट करने की आवश्यकता से बचाता है; इनपुट बिटस्ट्रिंग फर्स्ट से ही एक बिट ऐरे के रूप में होता है, और रेमैंडरपॉलीनोमियल संक्रियाओं के संदर्भ में मैनिपुलेट किया जाता है; $x$ से गुणा बाएँ या दाएँ शिफ्ट में हो सकता है, और बिटस्ट्रिंग[i+n] का ऐड $x^{0}$ गुणांक में किया जाता है, जो रजिस्टर का दायां या बायां अंत हो सकता है।

इस कोड की दो हानि होती हैं. सर्व प्रथम, इसे रेमैंडरपॉलीनोमियलको रखने के लिए वास्तव में n+1-बिट रजिस्टर की आवश्यकता होती है इस प्रकार $x^{n}$ गुणांक का परीक्षण किया जा सकता है। इससे भी महत्वपूर्ण बात यह है n शून्य बिट्स के साथ पैडेड होने के लिए बिटस्ट्रिंग की आवश्यकता होती है।

पहली समस्या को $x$ से गुणा करने से फर्स्ट रेमैंडरपॉलीनोमियल के $x^{n-1}$ गुणांक का परीक्षण करके हल किया जा सकता है।

दूसरी समस्या को अंतिम n पुनरावृत्तियों को अलग विधि से करके हल किया जा सकता है, परन्तु एक अधिक सूक्ष्म अनुकूलन होता है जिसका उपयोग हार्डवेयर और सॉफ्टवेयर दोनों इम्प्लीमेंटेशनों में सार्वभौमिक रूप से किया जाता है।

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

इससे मेसेज के फर्स्ट n बिट्स के साथ रेमैंडरपॉलीनोमियल को प्रीलोड करने की आवश्यकता समाप्त हो जाती है:

function crc(byte array string[1..len], int len) {
    remainderPolynomial := 0
    // A popular variant complements remainderPolynomial here; see § Preset to −1 below
    for i from 1 to len {
        remainderPolynomial := remainderPolynomial xor polynomialForm(string[i]) * xⁿ⁻⁸
        for j from 1 to 8 {    // Assuming 8 bits per byte
            if coefficient of xⁿ⁻¹ of remainderPolynomial = 1 {
                remainderPolynomial := (remainderPolynomial * x) xor generatorPolynomial
            } else {
                remainderPolynomial := (remainderPolynomial * x)
            }
        }
    }
    // A popular variant complements remainderPolynomial here; see § Post-invert below

    return remainderPolynomial
}

कोड फ्रेगमेंट 2: डिफर्ड XORing के साथ पॉलीनोमियल डिवीज़न

यह मानक बिट-ए-टाइम हार्डवेयर सीआरसी इम्प्लीमेंटेशन होता है, और अध्ययन के योग्य होता है; एक बार जब आप समझ जाते हैं कि यह फर्स्ट संस्करण के समान परिणाम की कंप्यूटिंग क्यों करता है, तो रेमैंडर अनुकूलन अत्यधिक सरल हो जाता हैं। यदि रेमैंडरपॉलीनोमियल मात्र n बिट लॉन्ग होता है, तो इसके और जनरेटरपॉलीनोमियल के $x^{n}$ गुणांक को सरलता से त्याग दिया जाता है। यही कारण है कि आप सामान्यतः सीआरसी पॉलीनोमियलों को बाइनरी में लिखे हुए देखेंगे, जिसमें प्रमुख गुणांक हटा दिया जाएगा।

सॉफ्टवेयर में, यह नोट करना सुविधाजनक है कि जहां कोई प्रत्येक बिट के xor को अंतिम क्षण तक विलंबित कर सकता है, वहीं इसे फर्स्ट करना भी संभव है। xor को एक समय में एक बाइट निष्पादित करना आमतौर पर सुविधाजनक होता है, यहां तक कि इस तरह से एक बिट-ए-टाइम इम्प्लीमेंटेशन में भी:

function crc(byte array string[1..len], int len) {
    remainderPolynomial := 0
    // A popular variant complements remainderPolynomial here; see § Preset to −1 below
    for i from 1 to len {
        remainderPolynomial := remainderPolynomial xor polynomialForm(string[i]) * xⁿ⁻⁸
        for j from 1 to 8 {    // Assuming 8 bits per byte
            if coefficient of xⁿ⁻¹ of remainderPolynomial = 1 {
                remainderPolynomial := (remainderPolynomial * x) xor generatorPolynomial
            } else {
                remainderPolynomial := (remainderPolynomial * x)
            }
        }
    }
    // A popular variant complements remainderPolynomial here; see § Post-invert below

    return remainderPolynomial
}

कोड फ्रेगमेंट 3: बाइटवाइज मेसेज XORing के साथ पॉलीनोमियल डिवीज़न

यह सामान्यतः सबसे कॉम्पैक्ट सॉफ़्टवेयर इम्प्लीमेंटेशन होता है, जिसका उपयोग माइक्रोकंट्रोलर्स में तब किया जाता है जब स्पेस प्रीमियम ओवर स्पीड पर होता है।

बिट ऑर्डरिंग (एंडियननेस)

जब बिट-सीरियल आर्किटेक्चर हार्डवेयर में प्रयुक्त किया जाता है, तो जनरेटर पॉलीनोमियल विशिष्ट रूप से बिट असाइनमेंट का वर्णन करता है; ट्रांसमिटेड प्रथम बिट सदैव उच्चतम पॉवर का गुणांक $x$ होता है, और लास्ट बात $n$ ट्रांसमिटेड बिट्स सीआरसी रेमैंडर $R(x)$ हैं , $x^{n-1}$ के गुणांक से प्रारंभ करते हुए और के $x^{0}$ गुणांक के साथ समाप्त होता है, अर्थात् 1 का गुणांक होता है।

यघपि, जब बिट्स को एक समय में एक बाइट संसाधित किया जाता है, जैसे कि समानांतर ट्रांसमिशन का उपयोग करते समय, 8बी/10बी एन्कोडिंग या आरएस-232-शैली एसिंक्रोनस सीरियल संचार के रूप में बाइट फ़्रेमिंग, या सॉफ़्टवेयर में सीआरसी प्रयुक्त करते समय, डेटा के बिट ऑर्डरिंग (एंडियननेस) को निर्दिष्ट करना आवश्यक होता है; प्रत्येक बाइट में कौन सा बिट "फर्स्ट" माना जाता है और उच्च पॉवर का गुणांक $x$ होता है।

यदि डेटा सीरियल कम्युनिकेशनर के लिए नियत है, तो बिट ऑर्डर का उपयोग करना सबसे अच्छा है जिससे डेटा अंततः भेजा जाएगा। ऐसा इसलिए है क्योंकि सीआरसी की बर्स्ट एरर का पता लगाने की क्षमता मेसेज पॉलीनोमियल $M(x)$ में निकटता पर आधारित होती है ; यदि आसन्न पॉलीनोमियल शब्दों को क्रमिक रूप सेट्रांसमिट नहीं किया जाता है, तो बिट्स के पुनर्व्यवस्था के कारण एक भौतिक एरर बर्स्ट को लॉन्ग बर्स्ट के रूप में देखा जा सकता है।

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

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

अब तक, स्यूडोकोड ने स्यूडोकोड में बदलावों को गुणन के रूप में वर्णित करके बाइट्स के भीतर बिट्स के क्रम को निर्दिष्ट करने से बचता है। $x$ और द्विआधारी से पॉलीनोमियल रूप में स्पष्ट रूपांतरण लिखना। व्यवहार में, सीआरसी को एक विरेमैंडर बिट-ऑर्डरिंग कन्वेंशन का उपयोग करके एक मानक बाइनरी रजिस्टर में रखा जाता है। एमएसबिट-फर्स्ट रूप में, सबसे महत्वपूर्ण बाइनरी बिट्स फर्स्ट भेजे जाएंगे और इसलिए इसमें उच्च-क्रम पॉलीनोमियल गुणांक होंगे, जबकि एलएसबिट-फर्स्ट रूप में, कम से कम महत्वपूर्ण बाइनरी बिट्स में उच्च-क्रम गुणांक होंगे। उपरोक्त स्यूडोकोड दोनों रूपों में लिखा जा सकता है। कंसर्टर्नर्स के लिए, यह 16-बिट सीआरसी-16-CCITT पॉलीनोमियल $x^{16}+x^{12}+x^{5}+1$ का उपयोग करता है।

// Most significant bit first (big-endian)
// x^16+x^12+x^5+1 = (1) 0001 0000 0010 0001 = 0x1021
function crc(byte array string[1..len], int len) {
    rem := 0
    // A popular variant complements rem here
    for i from 1 to len {
        rem  := rem xor (string[i] leftShift (n-8))   // n = 16 in this example
        for j from 1 to 8 {   // Assuming 8 bits per byte
            if rem and 0x8000 {   // if leftmost (most significant) bit is set
                rem  := (rem leftShift 1) xor 0x1021
            } else {
                rem  := rem leftShift 1
            }
            rem  := rem and 0xffff      // Trim remainder to 16 bits
        }
    }
    // A popular variant complements rem here

    return rem
}

'कोड फ्रेगमेंट 4: शिफ्ट रजिस्टर बेस्ड डिवीज़न, एमएसबी फर्स्ट

// Least significant bit first (little-endian)
// x^16+x^12+x^5+1 = 1000 0100 0000 1000 (1) = 0x8408
function crc(byte array string[1..len], int len) {
    rem  := 0
    // A popular variant complements rem here
    for i from 1 to len {
        rem  := rem xor string[i]
        for j from 1 to 8 {   // Assuming 8 bits per byte
            if rem and 0x0001 {   // if rightmost (most significant) bit is set
                rem  := (rem rightShift 1) xor 0x8408
            } else {
                rem  := rem rightShift 1
            }
        }
    }
    // A popular variant complements rem here

    return rem
}

कोड फ्रेगमेंट 5: शिफ्ट रजिस्टर बेस्ड डिवीज़न, एलएसबी फर्स्ट

ध्यान दें कि एलएसबिट-फर्स्ट फॉर्म शिफ्ट करने की आवश्यकता से बचाता है string[i] से फर्स्ट xor. किसी भी स्थिति में, सीआरसी के बाइट्स को उस क्रम में प्रसारित करना सुनिश्चित करें जो आपके चुने हुए बिट-ऑर्डरिंग कन्वेंशन के समरूप होता है।

ध्यान दें कि एलएसबिट-फर्स्ट फॉर्म से xorहले स्ट्रिंग [i] को स्थानांतरित करने की आवश्यकता से बचाता है। किसी भी स्थिति में, सीआरसी के बाइट्स को उस क्रम में प्रसारित करना सुनिश्चित करें जो आपके चुने हुए बिट-ऑर्डरिंग कन्वेंशन के समरूप होता है।

मल्टी-बिट कंप्यूटिंग

सरवटे एल्गोरिदम (एकल लुकअप टेबल)

एक अन्य सामान्य अनुकूलन प्रति पुनरावृत्ति एक से अधिक बिट लाभांश को संसाधित करने के लिएरेम के उच्चतम क्रम गुणांक द्वारा अनुक्रमित लुकअप टेबल का उपयोग करता है।^[3] सामान्यतः, 256-एंट्री लुकअप टेबल का उपयोग किया जाता है, जो बाहरी लूप (iऊपर) की बॉडी को प्रतिस्थापित करता है।

// Msbit-first
rem = (rem leftShift 8) xor big_endian_table[string[i] xor ((leftmost 8 bits of rem) rightShift (n-8))]
// Lsbit-first

rem = (rem rightShift 8) xor little_endian_table[string[i] xor (rightmost 8 bits of rem)]

कोड फ्रेगमेंट 6: टेबल आधारित डिवीज़न के कोर

सबसे सामान्यतः सामने आने वाले सीआरसी एल्गोरिदम में से एक को सीआरसी-32 के रूप में जाना जाता है, जिसका उपयोग (अन्य के अलावा) ईथरनेट, एफडीडीआई, ज़िप (फ़ाइल फॉर्मेट) और अन्य आर्काइव फॉर्मेट, और पोर्टेबल नेटवर्क ग्राफिक्स इमेज फॉर्मेट द्वारा किया जाता है। इसके पॉलीनोमियल को एमएसबिट-फर्स्ट को 0x04C11DB7, या एलएसबिट-फर्स्ट को 0xEDB88320 के रूप में लिखा जा सकता है। पोर्टेबल नेटवर्क ग्राफ़िक्स पर W3C वेबपेज में सीआरसी-32 के C में एक संक्षिप्त और सरल टेबल-संचालित इम्प्लीमेंटेशन के साथ एक अपेंडिक्स सम्मलित होता है।^[4] आप देखेंगे कि कोड यहां प्रस्तुत एलएसबिट-फर्स्ट बिट-एट-ए-टाइम स्यूडोकोड के समरूप होता है, और टेबल बिट-एट-ए-टाइम कोड का उपयोग करके बनाई गई है।

256-प्रविष्टि टेबल का उपयोग करना सामान्यतः सबसे सुविधाजनक होता है, लेकिन अन्य आकारों का उपयोग किया जा सकता है। छोटे माइक्रोकंट्रोलर में, एक समय में चार बिट्स को प्रोसेस करने के लिए 16-एंट्री टेबल का उपयोग करने से टेबल को छोटा रखते हुए उपयोगी गति में सुधार होता है। पर्याप्त स्टोरेज वाले कंप्यूटरों पर, a 65536-एंट्री टेबल का उपयोग एक समय में 16 बिट्स को प्रोसेस करने के लिए किया जा सकता है।

टेबल जनरेट करना

टेबल उत्पन्न करने वाला सॉफ़्टवेयर इतना छोटा और तेज़ है कि स्टोरेज से पूर्व-कंप्यूटिंग की गई टेबलओं को लोड करने की तुलना में प्रोग्राम स्टार्टअप पर उनकी कंप्यूटिंग करना आमतौर पर तेज़ होता है। एक लोकप्रिय तकनीक 256 संभावित 8-बिट बाइट्स के सीआरसी उत्पन्न करने के लिए 256 बार बिट-ए-टाइम कोड का उपयोग करना है। हालाँकि, उस संपत्ति का लाभ उठाकर इसे महत्वपूर्ण रूप से अनुकूलित किया जा सकता है table[i xor j] == table[i] xor table[j]. मात्र दो की पॉवरयों के अनुरूप टेबल प्रविष्टियों की सीधे कंप्यूटिंग करने की आवश्यकता है।

निम्नलिखित उदाहरण कोड में, सीआरसी का मान रखता है table[i]:

big_endian_table[0] := 0
crc := 0x8000 // Assuming a 16-bit polynomial
i := 1
do {
    if crc and 0x8000 {
        crc := (crc leftShift 1) xor 0x1021 // The CRC polynomial
    } else {
        crc := crc leftShift 1
    }
    // crc is the value of big_endian_table[i]; let j iterate over the already-initialized entries
    for j from 0 to i−1 {
        big_endian_table[i + j] := crc xor big_endian_table[j];
    }
    i := i leftshift 1

} while i < 256

'कोड फ्रेगमेंट 7: बाइट-एट-ए-टाइम सीआरसी टेबल जनरेशन, एमएसबी फर्स्ट'

little_endian_table[0] := 0
crc := 1;
i := 128
do {
    if crc and 1 {
        crc := (crc rightShift 1) xor 0x8408 // The CRC polynomial
    } else {
        crc := crc rightShift 1
    }
    // crc is the value of little_endian_table[i]; let j iterate over the already-initialized entries
    for j from 0 to 255 by 2 × i {
        little_endian_table[i + j] := crc xor little_endian_table[j];
    }
    i := i rightshift 1

} while i > 0

'कोड फ्रेगमेंट 8: बाइट-एट-ए-टाइम सीआरसी टेबल जनरेशन, एलएसबी फर्स्ट'

इन कोड नमूनों में, टेबल अनुक्रमणिका i + j के बराबर है i xor j; आप जो भी फॉर्म अधिक सुविधाजनक हो उसका उपयोग कर सकते हैं।

सीआरसी-32 एल्गोरिथ्म

यह सीआरसी के सीआरसी-32 संस्करण के लिए एक व्यावहारिक एल्गोरिदम है।^[5] सीआरसीटेबल एक कंप्यूटिंग का संस्मरण है जिसे मेसेज के प्रत्येक बाइट के लिए दोहराया जाना होगा (Computation of cyclic redundancy checks § Multi-bit computation).

Function CRC32
   Input:
      data:  Bytes     // Array of bytes
   Output:
      crc32: UInt32    // 32-bit unsigned CRC-32 value

// Initialize CRC-32 to starting value
crc32 ← 0xFFFFFFFF

for each byte in data do
   nLookupIndex ← (crc32 xor byte) and 0xFF
   crc32 ← (crc32 shr 8) xor CRCTable[nLookupIndex]  // CRCTable is an array of 256 32-bit constants

// Finalize the CRC-32 value by inverting all the bits
crc32 ← crc32 xor 0xFFFFFFFF
return crc32

C में, एल्गोरिथ्म इस प्रकार दिखता है:

#include <inttypes.h> // uint32_t, uint8_t

uint32_t CRC32(const uint8_t data[], size_t data_length) {
	uint32_t crc32 = 0xFFFFFFFFu;
	
	for (size_t i = 0; i < data_length; i++) {
		const uint32_t lookupIndex = (crc32 ^ data[i]) & 0xff;
		crc32 = (crc32 >> 8) ^ CRCTable[lookupIndex];  // CRCTable is an array of 256 32-bit constants
	}
	
	// Finalize the CRC-32 value by inverting all the bits
	crc32 ^= 0xFFFFFFFFu;
	return crc32;
}

एकाधिक टेबलओं का उपयोग करके बाइट-स्लाइसिंग

एक स्लाइस-बाय-एन (आमतौर पर सीआरसी32 के लिए स्लाइस-बाय-8; एन ≤ 64) एल्गोरिदम मौजूद है जो आमतौर पर सरवटे एल्गोरिदम की तुलना में प्रदर्शन को दोगुना या तिगुना कर देता है। एक समय में 8 बिट्स पढ़ने के बजाय, एल्गोरिदम एक समय में 8N बिट्स पढ़ता है। ऐसा करने से सुपरस्केलर प्रोसेसर पर प्रदर्शन अधिकतम हो जाता है।^[6]^[7]^[8]^[9] यह स्पष्ट नहीं है कि वास्तव में एल्गोरिदम का आविष्कार किसने किया था।^[10]

टेबल के बिना समानांतर कंप्यूटिंग

एक समय में किसी बाइट या शब्द का समानांतर अद्यतन बिना टेबल के भी स्पष्ट रूप से किया जा सकता है।^[11] इसका उपयोग आमतौर पर हाई-स्पीड हार्डवेयर इम्प्लीमेंटेशन में किया जाता है। प्रत्येक बिट के लिए 8 बिट्स को स्थानांतरित करने के बाद एक समीकरण हल किया जाता है। निम्नलिखित टेबल निम्नलिखित प्रतीकों का उपयोग करके कुछ सामान्य रूप से उपयोग किए जाने वाले पॉलीनोमियलों के समीकरणों को सूचीबद्ध करती हैं:

c_i	सीआरसी bit 7…0 (or 15…0) before update
r_i	सीआरसी bit 7…0 (or 15…0) after update
d_i	input data bit 7…0
e_i = d_i + c_i	e_p = e₇ + e₆ + … + e₁ + e₀ (parity bit)
s_i = d_i + c_i+8	s_p = s₇ + s₆ + … + s₁ + s₀ (parity bit)

Bit-wise update equations for some सीआरसी-8 पॉलीनोमियलs after 8 bits have been shifted in
पॉलीनोमियल:	(x⁷ + x³ + 1) × x (left-shifted सीआरसी-7-CCITT)	x⁸ + x⁵ + x⁴ + 1 (सीआरसी-8-Dallas/Maxim)
Coefficients:	0x12 = (0x09 << 1) (MSBF/normal)	0x8c (LSBF/reverse)
r₀ ← r₁ ← r₂ ← r₃ ← r₄ ← r₅ ← r₆ ← r₇ ←	0 e₀ + e₄ + e₇ e₁ + e₅ e₂ + e₆ e₃ + e₇ + e₀ + e₄ + e₇ e₄ + e₁ + e₅ e₅ + e₂ + e₆ e₆ + e₃ + e₇	e₀ + e₄ + e₁ + e₀ + e₅ + e₂ + e₁ e₁ + e₅ + e₂ + e₁ + e₆ + e₃ + e₂ + e₀ e₂ + e₆ + e₃ + e₂ + e₀ + e₇ + e₄ + e₃ + e₁ e₃ + e₀ + e₇ + e₄ + e₃ + e₁ e₄ + e₁ + e₀ e₅ + e₂ + e₁ e₆ + e₃ + e₂ + e₀ e₇ + e₄ + e₃ + e₁
C code fragments:	uint8_t c, d, e, f, r; … e = c ^ d; f = e ^ (e >> 4) ^ (e >> 7); r = (f << 1) ^ (f << 4);	uint8_t c, d, e, f, r; … e = c ^ d; f = e ^ (e << 3) ^ (e << 4) ^ (e << 6); r = f ^ (f >> 4) ^ (f >> 5);

Bit-wise update equations for some सीआरसी-16 पॉलीनोमियलs after 8 bits have been shifted in
पॉलीनोमियल:	x¹⁶ + x¹² + x⁵ + 1 (सीआरसी-16-CCITT)		x¹⁶ + x¹⁵ + x² + 1 (सीआरसी-16-ANSI)
Coefficients:	0x1021 (MSBF/normal)	0x8408 (LSBF/reverse)	0x8005 (MSBF/normal)	0xa001 (LSBF/reverse)
r₀ ← r₁ ← r₂ ← r₃ ← r₄ ← r₅ ← r₆ ← r₇ ← r₈ ← r₉ ← r₁₀ ← r₁₁ ← r₁₂ ← r₁₃ ← r₁₄ ← r₁₅ ←	s₄ + s₀ s₅ + s₁ s₆ + s₂ s₇ + s₃ s₄ s₅ + s₄ + s₀ s₆ + s₅ + s₁ s₇ + s₆ + s₂ c₀ + s₇ + s₃ c₁ + s₄ c₂ + s₅ c₃ + s₆ c₄ + s₇ + s₄ + s₀ c₅ + s₅ + s₁ c₆ + s₆ + s₂ c₇ + s₇ + s₃	c₈ + e₄ + e₀ c₉ + e₅ + e₁ c₁₀ + e₆ + e₂ c₁₁ + e₀ + e₇ + e₃ c₁₂ + e₁ c₁₃ + e₂ c₁₄ + e₃ c₁₅ + e₄ + e₀ e₀ + e₅ + e₁ e₁ + e₆ + e₂ e₂ + e₇ + e₃ e₃ e₄ + e₀ e₅ + e₁ e₆ + e₂ e₇ + e₃	s_p s₀ + s_p s₁ + s₀ s₂ + s₁ s₃ + s₂ s₄ + s₃ s₅ + s₄ s₆ + s₅ c₀ + s₇ + s₆ c₁ + s₇ c₂ c₃ c₄ c₅ c₆ c₇ + s_p	c₈ + e_p c₉ c₁₀ c₁₁ c₁₂ c₁₃ c₁₄ + e₀ c₁₅ + e₁ + e₀ e₂ + e₁ e₃ + e₂ e₄ + e₃ e₅ + e₄ e₆ + e₅ e₇ + e₆ e_p + e₇ e_p
C code fragments:	uint8_t d, s, t; uint16_t c, r; … s = d ^ (c >> 8); t = s ^ (s >> 4); r = (c << 8) ^ t ^ (t << 5) ^ (t << 12);	uint8_t d, e, f; uint16_t c, r; … e = c ^ d; f = e ^ (e << 4); r = (c >> 8) ^ (f << 8) ^ (f << 3) ^ (f >> 4);	uint8_t d, s, p; uint16_t c, r, t; … s = d ^ (c >> 8); p = s ^ (s >> 4); p = p ^ (p >> 2); p = p ^ (p >> 1); p = p & 1; t = p \| (s << 1); r = (c << 8) ^ (t << 15) ^ t ^ (t << 1);	uint8_t d, e, p; uint16_t c, r, f; … e = c ^ d; p = e ^ (e >> 4); p = p ^ (p >> 2); p = p ^ (p >> 1); p = p & 1; f = e \| (p << 8); r = (c >> 8) ^ (f << 6) ^ (f << 7) ^ (f >> 8);

टू-स्टेपीय कंप्यूटिंग

चूँकि सीआरसी-32 पॉलीनोमियल में बड़ी संख्या में पद होते हैं, एक समय में रेमैंडर बाइट की कंप्यूटिंग करते समय प्रत्येक बिट पिछले पुनरावृत्ति के कई बिट्स पर निर्भर करता है। बाइट-समानांतर हार्डवेयर इम्प्लीमेंटेशन में इसके लिए मल्टीपल-इनपुट या कैस्केड XOR गेट्स की आवश्यकता होती है जो प्रसार विलंब को बढ़ाता है।

कंप्यूटिंग गति को अधिकतम करने के लिए, 123-बिट शिफ्ट रजिस्टर के माध्यम से मेसेज को पारित करके एक मध्यवर्ती रेमैंडर की कंप्यूटिंग की जा सकती है। पॉलीनोमियल मानक पॉलीनोमियल का सावधानीपूर्वक चयनित गुणज होता है, जैसे कि पद (फीडबैक टैप) व्यापक रूप से दूरी पर हैं, और रेमैंडर का कोई भी बिट प्रति बाइट पुनरावृत्ति में एक बार से अधिक XORed नहीं होता है। इस प्रकार मात्र दो-इनपुट XOR गेट, सबसे तेज़ संभव, की आवश्यकता होती है। अंत में सीआरसी-32 रेमैंडर प्राप्त करने के लिए मध्यवर्ती रेमैंडर को दूसरी शिफ्ट रजिस्टर में मानक पॉलीनोमियल द्वारा विभाजित किया जाता है।^[12]

ब्लॉकवार कंप्यूटिंग

रेमैंडर की ब्लॉक-वार कंप्यूटिंग किसी भी सीआरसी पॉलीनोमियल के लिए हार्डवेयर में राज्य अंतरिक्ष परिवर्तन मैट्रिक्स को गुणनफ्रेगमेंटित करके की जा सकती है, जो रेमैंडर को दो सरल टोप्लिट्ज मैट्रिक्स में कंप्यूटिंग करने के लिए आवश्यक है।^[13]

एक-पास चेकिंग

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

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

सीआरसी वेरिएंट

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

=== −1 === पर प्रीसेट सीआरसी का बुनियादी गणित उन मेसेजों को स्वीकार करता है (सही ढंग से प्रसारित माना जाता है) जिन्हें पॉलीनोमियल के रूप में व्याख्या किए जाने पर, सीआरसी पॉलीनोमियल का एक गुणक होता है। यदि कुछ अग्रणी 0 बिट्स को ऐसे मेसेज से जोड़ा जाता है, तो वे पॉलीनोमियल के रूप में इसकी व्याख्या को नहीं बदलेंगे। यह इस तथ्य के समतुल्य है कि 0001 और 1 एक ही संख्या हैं।

लेकिन यदि ट्रांसमिटेड किया जा रहा मेसेज अग्रणी 0 बिट्स की परवाह करता है, तो ऐसे परिवर्तन का पता लगाने के लिए बुनियादी सीआरसी एल्गोरिदम की अक्षमता अवांछनीय है। यदि यह संभव है कि एक ट्रांसमिशन त्रुटि ऐसे बिट्स को जोड़ सकती है, तो एक सरल समाधान यह है कि प्रारम्भ करें rem शिफ्ट रजिस्टर को कुछ गैर-शून्य मान पर सेट किया गया; सुविधा के लिए, आमतौर पर ऑल-वन्स मान का उपयोग किया जाता है। यह गणितीय रूप से मेसेज के फर्स्ट एन बिट्स को पूरक करने (बाइनरी नोट) के बराबर है, जहां एन सीआरसी रजिस्टर में बिट्स की संख्या है।

यह सीआरसी निर्माण और जांच को किसी भी तरह से प्रभावित नहीं करता है, जब तक जनरेटर और चेकर दोनों समान प्रारंभिक मूल्य का उपयोग करते हैं। कोई भी गैर-शून्य प्रारंभिक मान काम करेगा, और कुछ मानक असामान्य मान निर्दिष्ट करते हैं,^[15] लेकिन सभी का मान (दो में −1 पूरक बाइनरी) अब तक का सबसे आम है। ध्यान दें कि एक-पास सीआरसी जनरेट/चेक पूर्व निर्धारित मूल्य की परवाह किए बिना, मेसेज सही होने पर भी शून्य का परिणाम देगा।

पोस्ट-उलटा

उसी प्रकार की त्रुटि मेसेज के अंत में हो सकती है, भले ही मेसेजों के अधिक सीमित सेट के साथ। किसी मेसेज में 0 बिट जोड़ना उसके पॉलीनोमियल को x से गुणा करने के बराबर है, और यदि यह फर्स्ट सीआरसी पॉलीनोमियल का गुणज था, तो उस गुणन का परिणाम भी होगा। यह इस तथ्य के समतुल्य है कि, चूँकि 726, 11 का गुणज है, इसलिए 7260 भी है।

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

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

यह भी देखें

सामान्य वर्ग

कोड सुधारने में त्रुटि
हैश फ़ंक्शंस की सूची
समता (दूरसंचार) पॉलीनोमियल के साथ 1-बिट सीआरसी के बराबर है $x +1$ .

गैर-सीआरसी चेकसम

एडलर-32
फ्लेचर का चेकसम

संदर्भ

↑ Dubrova, Elena; Mansouri, Shohreh Sharif (May 2012). "A BDD-Based Approach to Constructing LFSRS for Parallel CRC Encoding". 2012 IEEE 42nd International Symposium on Multiple-Valued Logic. pp. 128–133. doi:10.1109/ISMVL.2012.20. ISBN 978-0-7695-4673-5. S2CID 27306826.
↑ ^2.0 ^2.1 Williams, Ross N. (1996-09-24). "A Painless Guide to CRC Error Detection Algorithms V3.00". Archived from the original on 2006-09-27. Retrieved 2016-02-16.
↑ Sarwate, Dilip V. (August 1998). "टेबल लुक-अप के माध्यम से चक्रीय अतिरेक जांच की गणना". Communications of the ACM. 31 (8): 1008–1013. doi:10.1145/63030.63037. S2CID 5363350.
↑ "Portable Network Graphics (PNG) Specification (Second Edition): Annex D, Sample Cyclic Redundancy Code implementation". W3C. 2003-11-10. Retrieved 2016-02-16.
↑ "[MS-ABS]: 32-Bit CRC Algorithm". msdn.microsoft.com. Archived from the original on 7 November 2017. Retrieved 4 November 2017.
↑ Kounavis, M.E.; Berry, F.L. (2005). "A Systematic Approach to Building High Performance Software-Based CRC Generators". 10th IEEE Symposium on Computers and Communications (ISCC'05) (PDF). pp. 855–862. doi:10.1109/ISCC.2005.18. ISBN 0-7695-2373-0. S2CID 10308354.
↑ Berry, Frank L.; Kounavis, Michael E. (November 2008). "उच्च-प्रदर्शन सीआरसी पीढ़ी के लिए नवीन तालिका लुकअप-आधारित एल्गोरिदम". IEEE Transactions on Computers. 57 (11): 1550–1560. doi:10.1109/TC.2008.85. S2CID 206624854.
↑ High Octane CRC Generation with the Intel Slicing-by-8 Algorithm (PDF) (Technical report). Intel. Archived from the original (PDF) on 2012-07-22.
↑ "सीआरसी गणना पर संक्षिप्त ट्यूटोरियल". The Linux Kernel Archives.
↑ Menon-Sen, Abhijit (2017-01-20). "Who invented the slicing-by-N CRC32 algorithm?".
↑ Jon Buller (1996-03-15). "Re: 8051 and CRC-CCITT". Newsgroup: comp.arch.embedded. Usenet: 31498ED0.7C0A@nortel.com. Retrieved 2016-02-16.
↑ Glaise, René J. (1997-01-20). "A two-step computation of cyclic redundancy code CRC-32 for ATM networks". IBM Journal of Research and Development. Armonk, NY: IBM. 41 (6): 705. doi:10.1147/rd.416.0705. Archived from the original on 2009-01-30. Retrieved 2016-02-16.
↑ Das, Arindam (2022). "लुक-अप टेबल के स्थान पर फैक्टर्ड टोप्लिट्ज़ मैट्रिसेस का उपयोग करके चक्रीय रिडंडेंसी कोड की ब्लॉक-वार गणना". IEEE Transactions on Computers. 72 (4): 1110–1121. doi:10.1109/TC.2022.3189574. ISSN 0018-9340. S2CID 250472783.
↑ Andrew Kadatch, Bob Jenkins. "Everything we know about CRC but afraid to forget". 2007. quote: "The fact that the CRC of a message followed by its CRC is a constant value which does not depend on the message... is well known and has been widely used in the telecommunication industry for long time."
↑ E.g. low-frequency RFID TMS37157 data sheet - Passive Low Frequency Interface Device With EEPROM and 134.2 kHz Transponder Interface (PDF), Texas Instruments, November 2009, p. 39, retrieved 2016-02-16, The CRC Generator is initialized with the value 0x3791 as shown in Figure 50.

बाहरी संबंध

JohnPaul Adamovsky. "64 Bit Cyclic Redundant Code – XOR Long Division To Bytewise Table Lookup".

Andrew Kadarch, Bob Jenkins. "Efficient (~1 CPU cycle per byte) CRC implementation". GitHub.

[1] Dubrova, Elena; Mansouri, Shohreh Sharif (May 2012). "A BDD-Based Approach to Constructing LFSRS for Parallel CRC Encoding". 2012 IEEE 42nd International Symposium on Multiple-Valued Logic. pp. 128–133. doi:10.1109/ISMVL.2012.20. ISBN 978-0-7695-4673-5. S2CID 27306826.

[williams96-2] 2.0 ^2.1 Williams, Ross N. (1996-09-24). "A Painless Guide to CRC Error Detection Algorithms V3.00". Archived from the original on 2006-09-27. Retrieved 2016-02-16.

[3] Sarwate, Dilip V. (August 1998). "टेबल लुक-अप के माध्यम से चक्रीय अतिरेक जांच की गणना". Communications of the ACM. 31 (8): 1008–1013. doi:10.1145/63030.63037. S2CID 5363350.

[4] "Portable Network Graphics (PNG) Specification (Second Edition): Annex D, Sample Cyclic Redundancy Code implementation". W3C. 2003-11-10. Retrieved 2016-02-16.

[5] "[MS-ABS]: 32-Bit CRC Algorithm". msdn.microsoft.com. Archived from the original on 7 November 2017. Retrieved 4 November 2017.

[6] Kounavis, M.E.; Berry, F.L. (2005). "A Systematic Approach to Building High Performance Software-Based CRC Generators". 10th IEEE Symposium on Computers and Communications (ISCC'05) (PDF). pp. 855–862. doi:10.1109/ISCC.2005.18. ISBN 0-7695-2373-0. S2CID 10308354.

[7] Berry, Frank L.; Kounavis, Michael E. (November 2008). "उच्च-प्रदर्शन सीआरसी पीढ़ी के लिए नवीन तालिका लुकअप-आधारित एल्गोरिदम". IEEE Transactions on Computers. 57 (11): 1550–1560. doi:10.1109/TC.2008.85. S2CID 206624854.

[8] High Octane CRC Generation with the Intel Slicing-by-8 Algorithm (PDF) (Technical report). Intel. Archived from the original (PDF) on 2012-07-22.

[9] "सीआरसी गणना पर संक्षिप्त ट्यूटोरियल". The Linux Kernel Archives.

[10] Menon-Sen, Abhijit (2017-01-20). "Who invented the slicing-by-N CRC32 algorithm?".

[11] Jon Buller (1996-03-15). "Re: 8051 and CRC-CCITT". Newsgroup: comp.arch.embedded. Usenet: 31498ED0.7C0A@nortel.com. Retrieved 2016-02-16.

[glaise-12] Glaise, René J. (1997-01-20). "A two-step computation of cyclic redundancy code CRC-32 for ATM networks". IBM Journal of Research and Development. Armonk, NY: IBM. 41 (6): 705. doi:10.1147/rd.416.0705. Archived from the original on 2009-01-30. Retrieved 2016-02-16.

[13] Das, Arindam (2022). "लुक-अप टेबल के स्थान पर फैक्टर्ड टोप्लिट्ज़ मैट्रिसेस का उपयोग करके चक्रीय रिडंडेंसी कोड की ब्लॉक-वार गणना". IEEE Transactions on Computers. 72 (4): 1110–1121. doi:10.1109/TC.2022.3189574. ISSN 0018-9340. S2CID 250472783.

[14] Andrew Kadatch, Bob Jenkins. "Everything we know about CRC but afraid to forget". 2007. quote: "The fact that the CRC of a message followed by its CRC is a constant value which does not depend on the message... is well known and has been widely used in the telecommunication industry for long time."

[15] E.g. low-frequency RFID TMS37157 data sheet - Passive Low Frequency Interface Device With EEPROM and 134.2 kHz Transponder Interface (PDF), Texas Instruments, November 2009, p. 39, retrieved 2016-02-16, The CRC Generator is initialized with the value 0x3791 as shown in Figure 50.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

Anonymous

Search

चक्रीय अतिरेक जांच की गणना: Difference between revisions

Namespaces

More

Page actions

Revision as of 22:31, 2 August 2023

Contents

उदाहरण

इम्प्लीमेंटेशन

बिट ऑर्डरिंग (एंडियननेस)

मल्टी-बिट कंप्यूटिंग

सरवटे एल्गोरिदम (एकल लुकअप टेबल)

टेबल जनरेट करना

सीआरसी-32 एल्गोरिथ्म

एकाधिक टेबलओं का उपयोग करके बाइट-स्लाइसिंग

टेबल के बिना समानांतर कंप्यूटिंग

टू-स्टेपीय कंप्यूटिंग

ब्लॉकवार कंप्यूटिंग

सीआरसी वेरिएंट

पोस्ट-उलटा

यह भी देखें

संदर्भ

बाहरी संबंध

Navigation

Navigation

Wiki tools

Wiki tools

@@ Line 1: / Line 1: @@
-{{short description|Overview of the computation of cyclic redundancy checks}}'''साइक्लिक रिडंडेंसी जांच की कंप्यूटिंग''' बहुपद डिवीज़न , मोडुलो टू के गणित से ली गई है। व्यवहार में, यह [[बाइनरी कोड]] मेसेज स्ट्रिंग के लॉन्ग डिवीज़न  जैसा दिखता है, जिसमें जेनरेटर बहुपद स्ट्रिंग द्वारा निश्चित संख्या में शून्य जोड़े जाते हैं, अतिरिक्त इसके कि [[एकमात्र]] ऑपरेशन रिप्लेस का स्थान लेते हैं। इस प्रकार का डिवीज़न  एक संशोधित [[ शिफ्ट का रजिस्टर ]] द्वारा हार्डवेयर में कुशलतापूर्वक किया जाता है,<ref>{{cite book
+{{short description|Overview of the computation of cyclic redundancy checks}}'''साइक्लिक रिडंडेंसी जांच की कंप्यूटिंग''' पॉलीनोमियल डिवीज़न , मोडुलो टू के गणित से ली गई है। व्यवहार में, यह [[बाइनरी कोड]] मेसेज स्ट्रिंग के लॉन्ग डिवीज़न  जैसा दिखता है, जिसमें जेनरेटर पॉलीनोमियल स्ट्रिंग द्वारा निश्चित संख्या में शून्य जोड़े जाते हैं, अतिरिक्त इसके कि [[एकमात्र]] ऑपरेशन रिप्लेस का स्थान लेते हैं। इस प्रकार का डिवीज़न  एक संशोधित [[ शिफ्ट का रजिस्टर ]] द्वारा हार्डवेयर में कुशलतापूर्वक किया जाता है,<ref>{{cite book
 | first1=Elena
 | last1=Dubrova
@@ Line 23: / Line 23: @@
 }}</ref>
-[[Image:CRC8-gen.gif|thumb|right|380 px|8-बिट साइक्लिक रिडंडेंसी जांच उत्पन्न करने का उदाहरण। जनरेटर एक गैलोइस-प्रकार का [[लीनियर-फीडबैक शिफ्ट रजिस्टर]] है जिसमें जनरेटर बहुपद में x की शक्तियों (सफेद संख्या) के अनुसार XOR गेट लगाए गए हैं। मेसेज स्ट्रीम किसी भी लॉन्गई की हो सकती है. इसे रजिस्टर के माध्यम से स्थानांतरित करने के बाद, 8 शून्य के बाद, रजिस्टर में परिणाम चेकसम है।]]
+[[Image:CRC8-gen.gif|thumb|right|380 px|8-बिट साइक्लिक रिडंडेंसी जांच उत्पन्न करने का उदाहरण। जनरेटर एक गैलोइस-प्रकार का [[लीनियर-फीडबैक शिफ्ट रजिस्टर]] है जिसमें जनरेटर पॉलीनोमियल में x की पॉवरयों (सफेद संख्या) के अनुसार XOR गेट लगाए गए हैं। मेसेज स्ट्रीम किसी भी लॉन्गई की हो सकती है. इसे रजिस्टर के माध्यम से स्थानांतरित करने के बाद, 8 शून्य के बाद, रजिस्टर में परिणाम चेकसम है।]]
-[[Image:CRC8-rx.gif|thumb|380 px|चेकसम के साथ प्राप्त डेटा की जाँच करना। प्राप्त मेसेज को उसी रजिस्टर के माध्यम से स्थानांतरित किया जाता है जैसा कि जनरेटर में उपयोग किया जाता है, लेकिन प्राप्त चेकसम शून्य के बजाय इसके साथ जुड़ा होता है। सही डेटा से सर्व-शून्य परिणाम प्राप्त होता है; मेसेज या चेकसम में एक दूषित बिट एक अलग परिणाम देगा, चेतावनी देगा कि कोई त्रुटि हुई है।]]विभिन्न सीआरसी मानक एक प्रारंभिक शिफ्ट रजिस्टर मान, एक अंतिम एक्सक्लूसिव-या स्टेप और, सबसे गंभीर रूप से, थोड़ा ऑर्डरिंग ([[endianness|अंतहीनता]]) निर्दिष्ट करके बहुपद डिवीज़न  एल्गोरिदम का विस्तार करते हैं। परिणामस्वरूप, व्यवहार में देखा जाने वाला कोड प्योर डिवीज़न से कंफ्यूज  रूप से भटक जाता है,<ref name="williams96"/>और रजिस्टर बाएँ या दाएँ शिफ्ट हो सकता है।
+[[Image:CRC8-rx.gif|thumb|380 px|चेकसम के साथ प्राप्त डेटा की जाँच करना। प्राप्त मेसेज को उसी रजिस्टर के माध्यम से स्थानांतरित किया जाता है जैसा कि जनरेटर में उपयोग किया जाता है, लेकिन प्राप्त चेकसम शून्य के बजाय इसके साथ जुड़ा होता है। सही डेटा से सर्व-शून्य परिणाम प्राप्त होता है; मेसेज या चेकसम में एक दूषित बिट एक अलग परिणाम देगा, चेतावनी देगा कि कोई त्रुटि हुई है।]]विभिन्न सीआरसी मानक एक प्रारंभिक शिफ्ट रजिस्टर मान, एक अंतिम एक्सक्लूसिव-या स्टेप और, सबसे गंभीर रूप से, थोड़ा ऑर्डरिंग ([[endianness|अंतहीनता]]) निर्दिष्ट करके पॉलीनोमियल डिवीज़न  एल्गोरिदम का विस्तार करते हैं। परिणामस्वरूप, व्यवहार में देखा जाने वाला कोड प्योर डिवीज़न से कंफ्यूज  रूप से भटक जाता है,<ref name="williams96"/>और रजिस्टर बाएँ या दाएँ शिफ्ट हो सकता है।
 == उदाहरण ==
-हार्डवेयर में बहुपद डिवीज़न को प्रयुक्त करने के एक उदाहरण के रूप में, मान लीजिए कि हम [[ASCII]] वर्ण W से बने 8-बिट मेसेज के 8-बिट CRC की कंप्यूटिंग करने का प्रयास कर रहे हैं, जो बाइनरी 01010111 है, डेसिमल 87<sub>10</sub>, या [[हेक्साडेसिमल]] 57<sub>16</sub> होता है। उदाहरण के लिए, हम CRC-8-ATM (HEC) पोल्य्नोमिअल  <math>x^8+x^2+x+1</math> का उपयोग करेंगे। प्रेषित पहली बिट ट्रांसमिट(उच्चतम शक्ति का गुणांक <math>x</math>) बाईं ओर, यह 9-बिट स्ट्रिंग 100000111 के समरूप होता है।
+हार्डवेयर में पॉलीनोमियल डिवीज़न को प्रयुक्त करने के एक उदाहरण के रूप में, मान लीजिए कि हम [[ASCII]] वर्ण W से बने 8-बिट मेसेज के 8-बिट सीआरसी की कंप्यूटिंग करने का प्रयास कर रहे हैं, जो बाइनरी 01010111 है, डेसिमल 87<sub>10</sub>, या [[हेक्साडेसिमल]] 57<sub>16</sub> होता है। उदाहरण के लिए, हम सीआरसी-8-ATM (HEC) पोल्य्नोमिअल  <math>x^8+x^2+x+1</math> का उपयोग करेंगे। ट्रांसमिटेड पहली बिट ट्रांसमिट(उच्चतम पॉवर का गुणांक <math>x</math>) बाईं ओर, यह 9-बिट स्ट्रिंग 100000111 के समरूप होता है।
-बाइट मान 57<sub>16</sub> उपयोग किए गए बिट ऑर्डरिंग कन्वेंशन के आधार पर, दो अलग-अलग ऑर्डर में प्रसारित किया जा सकता है। प्रत्येक एक अलग मेसेज बहुपद <math>M(x)</math> उत्पन्न करता है। एमएसबिट-फर्स्ट, यह<math>x^6+x^4+x^2+x+1</math> = 01010111 होता है, जबकि एलएसबिट-फर्स्ट, यह <math>x^7+x^6+x^5+x^3+x</math> = 11101010 होता है। दो 16-बिट मेसेज बहुपद <math>x^8 M(x)</math>बनाने के लिए इन्हे <math>x^8</math> से गुणा किया जा सकता है।
+बाइट मान 57<sub>16</sub> उपयोग किए गए बिट ऑर्डरिंग कन्वेंशन के आधार पर, दो अलग-अलग ऑर्डर में प्रसारित किया जा सकता है। प्रत्येक एक अलग मेसेज पॉलीनोमियल <math>M(x)</math> उत्पन्न करता है। एमएसबिट-फर्स्ट, यह<math>x^6+x^4+x^2+x+1</math> = 01010111 होता है, जबकि एलएसबिट-फर्स्ट, यह <math>x^7+x^6+x^5+x^3+x</math> = 11101010 होता है। दो 16-बिट मेसेज पॉलीनोमियल <math>x^8 M(x)</math>बनाने के लिए इन्हे <math>x^8</math> से गुणा किया जा सकता है।
-फिर शेषफल की कंप्यूटिंग में जेनरेटर बहुपद <math>G(x)</math>के गुणजों को सब्सट्रैक्ट करना सम्मिलित होता है। यह सम्पूर्ण रूप में दशमलव लॉन्ग डिवीज़न के अनुरूप होता है, परन्तु इससे सरल होता है क्योंकि प्रत्येक स्टेप में एकमात्र संभावित गुणज 0 और 1 होते हैं, और ऊपरी अंकों को कम करने के अतिरिक्त सबस्ट्रक्शन इनफिनिटी से बोर्रो किया जाता है। चूँकि हमें भागफल की केयर नहीं है, इसलिए इसे रिकॉर्ड करने की कोई आवश्यकता नहीं होती है।
+फिर रेमैंडरफल की कंप्यूटिंग में जेनरेटर पॉलीनोमियल <math>G(x)</math>के गुणजों को सब्सट्रैक्ट करना सम्मिलित होता है। यह सम्पूर्ण रूप में दशमलव लॉन्ग डिवीज़न के अनुरूप होता है, परन्तु इससे सरल होता है क्योंकि प्रत्येक स्टेप में एकमात्र संभावित गुणज 0 और 1 होते हैं, और ऊपरी अंकों को कम करने के अतिरिक्त सबस्ट्रक्शन इनफिनिटी से बोर्रो किया जाता है। चूँकि हमें भागफल की केयर नहीं है, इसलिए इसे रिकॉर्ड करने की कोई आवश्यकता नहीं होती है।
 {| border="1" style="margin:auto;"
-! Most-significant bit first !! Least-significant bit first
+! Most-significant bit फर्स्ट !! Least-significant bit फर्स्ट
 |-
 |
@@ Line 111: / Line 111: @@
 |}
 |}
-ध्यान दें कि प्रत्येक सबस्ट्रक्शन के पश्चात्, बिट्स को तीन समूहों में विभाजित किया जाता है: प्रारम्भ में, एक समूह जो सभी शून्य होता है; अंत में, एक समूह जो मूल से अपरिवर्तित होता  है; और मध्य में एक नीला शेडेड समूह होता जो इंटररेस्टिंग होता है। इंटररेस्टिंग समूह 8 बिट लॉन्ग होता है, जो बहुपद की डिग्री के समरूप होता है। प्रत्येक स्टेप में, शून्य समूह को एक बिट लॉन्ग बनाने के लिए बहुपद के उपयुक्त गुणज को सब्सट्रैक्ट किया जाता है, और अपरिवर्तित समूह एक बिट छोटा हो जाता है, जब तक कि मात्र अंतिम शेष न बचा हो।
+ध्यान दें कि प्रत्येक सबस्ट्रक्शन के पश्चात्, बिट्स को तीन समूहों में विभाजित किया जाता है: प्रारम्भ में, एक समूह जो सभी शून्य होता है; अंत में, एक समूह जो मूल से अपरिवर्तित होता  है; और मध्य में एक नीला शेडेड समूह होता जो इंटररेस्टिंग होता है। इंटररेस्टिंग समूह 8 बिट लॉन्ग होता है, जो पॉलीनोमियल की डिग्री के समरूप होता है। प्रत्येक स्टेप में, शून्य समूह को एक बिट लॉन्ग बनाने के लिए पॉलीनोमियल के उपयुक्त गुणज को सब्सट्रैक्ट किया जाता है, और अपरिवर्तित समूह एक बिट छोटा हो जाता है, जब तक कि मात्र अंतिम रेमैंडर न बचा हो।
-एमएसबिट-फर्स्ट उदाहरण में, शेष बहुपद <math>x^7+x^5+x</math> होता है। हेक्साडेसिमल संख्या को कनवर्ट करने के लिए  कन्वेंशन का उपयोग किया जाता है जो  x की उच्चतम शक्ति एमएसबिट होता  है; यह A2<sub>16</sub> होता है। एलएसबिट-फर्स्ट में शेषफल  <math>x^7+x^4+x^3</math> होता है। हेक्साडेसिमल संख्या को कनवर्ट करने के लिए  कन्वेंशन का उपयोग किया जाता है जो  x की उच्चतम शक्ति एलएसबिट होता  है; यह 19<sub>16</sub> होता है।
+एमएसबिट-फर्स्ट उदाहरण में, रेमैंडर पॉलीनोमियल <math>x^7+x^5+x</math> होता है। हेक्साडेसिमल संख्या को कनवर्ट करने के लिए  कन्वेंशन का उपयोग किया जाता है जो  x की उच्चतम पॉवर एमएसबिट होता  है; यह A2<sub>16</sub> होता है। एलएसबिट-फर्स्ट में रेमैंडरफल  <math>x^7+x^4+x^3</math> होता है। हेक्साडेसिमल संख्या को कनवर्ट करने के लिए  कन्वेंशन का उपयोग किया जाता है जो  x की उच्चतम पॉवर एलएसबिट होता  है; यह 19<sub>16</sub> होता है।
-== कार्यान्वयन ==
+== इम्प्लीमेंटेशन ==
-प्रत्येक स्टेप पर पूरा मेसेज लिखना, जैसा कि ऊपर दिए गए उदाहरण में किया गया है, बहुत कठिन होता है। मात्र  इंटररेस्टिंग बिट्स को रखने के लिए कुशल कार्यान्वयन <math>n</math>-बिट शिफ्ट रजिस्टर का उपयोग करता है। बहुपद का  <math>x</math> से गुणा किया जाता है जो रजिस्टर को एक स्थान से स्थानांतरित करने के समान होता है, क्योंकि गुणांक मूल्य में नहीं बदलते हैं बल्कि मात्र  बहुपद के अगले पद तक बढ़ते हैं।
+प्रत्येक स्टेप पर पूरा मेसेज लिखना, जैसा कि ऊपर दिए गए उदाहरण में किया गया है, बहुत कठिन होता है। मात्र  इंटररेस्टिंग बिट्स को रखने के लिए कुशल इम्प्लीमेंटेशन <math>n</math>-बिट शिफ्ट रजिस्टर का उपयोग करता है। पॉलीनोमियल का  <math>x</math> से गुणा किया जाता है जो रजिस्टर को एक स्थान से स्थानांतरित करने के समान होता है, क्योंकि गुणांक मूल्य में नहीं बदलते हैं बल्कि मात्र  पॉलीनोमियल के अगले पद तक बढ़ते हैं।
-यहां एन-बिट सीआरसी की कंप्यूटिंग के लिए कुछ स्यूडोकोड का फर्स्ट ड्राफ्ट होता है। यह बहुपदों के लिए एक काल्पनिक वस्तु संरचना का उपयोग करता है, जहाँ <code>''x''</code> एक पूर्णांक चर नहीं होता है, तथापि  एक [[कंस्ट्रक्टर (कंप्यूटर विज्ञान)|कंस्ट्रक्टर]] एक बहुपद [[वस्तु (कंप्यूटर विज्ञान)|ऑब्जेक्ट]]  उत्पन्न करता है जिसे जोड़ा, गुणा और घातांकित किया जा सकता है। <code>'''xor'''</code> के लिए दो बहुपदों को जोड़ा जाता है, मॉड्यूलो दो; अर्थात्, दोनों बहुपदों से प्रत्येक मिलान पद के गुणांकों को अलग किया जाता है।
+यहां एन-बिट सीआरसी की कंप्यूटिंग के लिए कुछ स्यूडोकोड का फर्स्ट ड्राफ्ट होता है। यह पॉलीनोमियलों के लिए एक काल्पनिक वस्तु संरचना का उपयोग करता है, जहाँ <code>''x''</code> एक पूर्णांक चर नहीं होता है, तथापि  एक [[कंस्ट्रक्टर (कंप्यूटर विज्ञान)|कंस्ट्रक्टर]] एक पॉलीनोमियल [[वस्तु (कंप्यूटर विज्ञान)|ऑब्जेक्ट]]  उत्पन्न करता है जिसे जोड़ा, गुणा और घातांकित किया जा सकता है। <code>'''xor'''</code> के लिए दो पॉलीनोमियलों को जोड़ा जाता है, मॉड्यूलो दो; अर्थात्, दोनों पॉलीनोमियलों से प्रत्येक मिलान पद के गुणांकों को अलग किया जाता है।
-  फ़ंक्शन सीआरसी(बिट ऐरे बिटस्ट्रिंग[1..लेन], इंट लेन) {
+  '''function''' crc(''bit array'' bitString[1..len], ''int'' len) {
-     remainderPolynomial := '''polynomialForm'''(bitString[1..n])   ''// First n bits of the message''
+     remainderPolynomial := 0
-      ''// A popular variant complements remainderPolynomial here; see § Preset to −1 below''
+      ''// A popular variant complements remainderPolynomial here; see {{slink||Preset to −1}} below''
       '''for''' i '''from''' 1 '''to''' len {
-          remainderPolynomial := remainderPolynomial * ''x'' + bitString[i+n] * ''x''<sup>0</sup>   ''// Define bitString[k]=0 for k>len''
+          remainderPolynomial := remainderPolynomial '''xor''' (bitstring[i] * ''x''<sup>n−1</sup>)
-          '''if''' coefficient of ''x''<sup>n</sup> of remainderPolynomial = 1 {
+          '''if''' (coefficient of ''x''<sup>n−1</sup> of remainderPolynomial) = 1 {
-              remainderPolynomial := remainderPolynomial '''xor''' generatorPolynomial
+              remainderPolynomial := (remainderPolynomial * ''x'') '''xor''' generatorPolynomial
+         } '''else''' {
+             remainderPolynomial := (remainderPolynomial * ''x'')
           }
       }
-      ''// A popular variant complements remainderPolynomial here; see § Post-invert below''
+      ''// A popular variant complements remainderPolynomial here; see {{slink||Post-invert}} below''
       '''return''' remainderPolynomial
   }
-:कोड खंड 1: सरल बहुपद डिवीज़न ''{{slink||Preset to −1}}'' ''{{slink||Post-invert}}''
+:कोड फ्रेगमेंट 1: सरल पॉलीनोमियल डिवीज़न
-ध्यान दें कि यह उदाहरण कोड बाइट्स का उपयोग न करके बिट-ऑर्डरिंग कन्वेंशन को निर्दिष्ट करने की आवश्यकता से बचाता है; इनपुट <code>bitString</code> पहले से ही एक बिट ऐरे के रूप में है, और <code>remainderPolynomial</code> बहुपद संक्रियाओं के संदर्भ में हेरफेर किया जाता है; से गुणा <math>x</math> बाएँ या दाएँ बदलाव, और का जोड़ हो सकता है <code>bitString[i+n]</code> को किया जाता है <math>x^0</math> गुणांक, जो रजिस्टर का दायां या बायां छोर हो सकता है।
+ध्यान दें कि यह उदाहरण कोड बाइट्स का उपयोग न करके बिट-ऑर्डरिंग कन्वेंशन को निर्दिष्ट करने की आवश्यकता से बचाता है; इनपुट <code>बिटस्ट्रिंग</code> फर्स्ट से ही एक बिट ऐरे के रूप में होता है, और <code>रेमैंडरपॉलीनोमियल</code>  संक्रियाओं के संदर्भ में मैनिपुलेट किया जाता है; <math>x</math> से गुणा  बाएँ या दाएँ शिफ्ट में हो सकता है, और  <code>बिटस्ट्रिंग[i+n]</code> का ऐड  <math>x^0</math> गुणांक में किया जाता है, जो रजिस्टर का दायां या बायां अंत हो सकता है।
-इस कोड के दो नुकसान हैं. सबसे पहले, इसे रखने के लिए वास्तव में n+1-बिट रजिस्टर की आवश्यकता होती है <code>remainderPolynomial</code> वैसा ही किया <math>x^n</math> गुणांक का परीक्षण किया जा सकता है। इससे भी महत्वपूर्ण बात यह है कि इसकी आवश्यकता है <code>bitString</code> n शून्य बिट्स के साथ गद्देदार होना।
+इस कोड की दो हानि होती हैं. सर्व प्रथम, इसे <code>रेमैंडरपॉलीनोमियल</code>को रखने के लिए वास्तव में n+1-बिट रजिस्टर की आवश्यकता होती है  इस प्रकार  <math>x^n</math> गुणांक का परीक्षण किया जा सकता है। इससे भी महत्वपूर्ण बात यह है n शून्य बिट्स के साथ पैडेड होने के लिए <code>बिटस्ट्रिंग</code> की आवश्यकता होती  है।
-पहली समस्या का परीक्षण करके हल किया जा सकता है <math>x^{n-1}</math> का गुणांक <code>remainderPolynomial</code> इससे पहले कि इसे गुणा किया जाए <math>x</math>.
+पहली समस्या को <math>x</math> से गुणा करने से फर्स्ट <code>रेमैंडरपॉलीनोमियल</code> के <math>x^{n-1}</math> गुणांक का परीक्षण करके हल किया जा सकता है।
-दूसरी समस्या को अंतिम n पुनरावृत्तियों को अलग ढंग से करके हल किया जा सकता है, लेकिन एक अधिक सूक्ष्म अनुकूलन है जिसका उपयोग हार्डवेयर और सॉफ्टवेयर दोनों कार्यान्वयनों में सार्वभौमिक रूप से किया जाता है।
+दूसरी समस्या को अंतिम n पुनरावृत्तियों को अलग विधि से करके हल किया जा सकता है, परन्तु एक अधिक सूक्ष्म अनुकूलन होता है जिसका उपयोग हार्डवेयर और सॉफ्टवेयर दोनों इम्प्लीमेंटेशनों में सार्वभौमिक रूप से किया जाता है।
-क्योंकि मेसेज से जनरेटर बहुपद को घटाने के लिए उपयोग किया जाने वाला XOR ऑपरेशन क्रम[[विनिमेय]] और साहचर्य है, इससे कोई फर्क नहीं पड़ता कि विभिन्न इनपुट किस क्रम में संयुक्त हैं <code>remainderPolynomial</code>. और विशेष रूप से, का एक दिया गया बिट <code>bitString</code> में जोड़ने की आवश्यकता नहीं है <code>remainderPolynomial</code> अंतिम क्षण तक जब यह निर्धारित करने के लिए परीक्षण किया जाता है कि क्या करना है <code>xor</code> साथ <code>generatorPolynomial</code>.
+क्योंकि मेसेज से जनरेटर पॉलीनोमियल को घटाने के लिए उपयोग किया जाने वाला XOR ऑपरेशन कम्युएटीव और अस्सोसिएटिव होता है, इससे कोई अंतर  नहीं पड़ता कि विभिन्न इनपुट <code>रेमैंडरपॉलीनोमियल</code> से किस क्रम में संयुक्त होते हैं।  और विरेमैंडर रूप से, <code>बिटस्ट्रिंग</code> के दिए गए बिट को अंतिम क्षण तक <code>रेमैंडरपॉलीनोमियल</code> में जोड़ने की आवश्यकता नहीं होती है  जब यह निर्धारित करने के लिए परीक्षण किया जाता है कि <code>जनरेटरपॉलीनोमियल</code>के साथ <code>xor</code> करना है या नहीं।
-इससे प्रीलोड करने की आवश्यकता समाप्त हो जाती है <code>remainderPolynomial</code> मेसेज के पहले n बिट्स के साथ:
+इससे मेसेज के फर्स्ट n बिट्स के साथ <code>रेमैंडरपॉलीनोमियल</code> को प्रीलोड करने की आवश्यकता समाप्त हो जाती है:
-  'फ़ंक्शन' सीआरसी (बिट सरणी बिटस्ट्रिंग [1..लेन], इंट लेन) {
+  '''function''' crc(''byte array'' string[1..len], ''int'' len) {
-      शेषबहुपद := 0
+      remainderPolynomial := 0
-      // एक लोकप्रिय संस्करण यहां शेष बहुपद का पूरक है; देखना {{slink||Preset to −1}} below''
+      ''// A popular variant complements remainderPolynomial here; see {{slink||Preset to −1}} below''
       '''for''' i '''from''' 1 '''to''' len {
-          remainderPolynomial := remainderPolynomial '''xor''' (bitstring[i] * ''x''<sup>n−1</sup>)
+          remainderPolynomial := remainderPolynomial '''xor''' '''polynomialForm'''(string[i]) * x<sup>n−8</sup>
-          '''if''' (coefficient of ''x''<sup>n−1</sup> of remainderPolynomial) = 1 {
+          '''for''' j '''from''' 1 '''to''' 8 {    ''// Assuming 8 bits per byte''
-             remainderPolynomial := (remainderPolynomial * ''x'') '''xor''' generatorPolynomial
+             '''if''' coefficient of ''x''<sup>n−1</sup> of remainderPolynomial = 1 {
-         } '''else''' {
+                 remainderPolynomial := (remainderPolynomial * ''x'') '''xor''' generatorPolynomial
-             remainderPolynomial := (remainderPolynomial * ''x'')
+             } '''else''' {
+                 remainderPolynomial := (remainderPolynomial * ''x'')
+             }
           }
       }
       ''// A popular variant complements remainderPolynomial here; see {{slink||Post-invert}} below''
       '''return''' remainderPolynomial
   }
-:कोड खंड 2: विलंबित मेसेज XORing के साथ बहुपद डिवीज़न
+:कोड फ्रेगमेंट 2: डिफर्ड XORing के साथ पॉलीनोमियल डिवीज़न
-यह मानक बिट-ए-टाइम हार्डवेयर सीआरसी कार्यान्वयन है, और अध्ययन के योग्य है; एक बार जब आप समझ जाते हैं कि यह पहले संस्करण के समान परिणाम की कंप्यूटिंग क्यों करता है, तो शेष अनुकूलन काफी सरल हैं। अगर <code>remainderPolynomial</code> मात्र n बिट लॉन्ग है, तो <math>x^n</math> इसके और के गुणांक <code>generatorPolynomial</code> बस त्याग दिए जाते हैं. यही कारण है कि आप आमतौर पर सीआरसी बहुपदों को बाइनरी में लिखे हुए देखेंगे, जिसमें प्रमुख गुणांक हटा दिया जाएगा।
+यह मानक बिट-ए-टाइम हार्डवेयर सीआरसी इम्प्लीमेंटेशन होता है, और अध्ययन के योग्य होता है; एक बार जब आप समझ जाते हैं कि यह फर्स्ट संस्करण के समान परिणाम की कंप्यूटिंग क्यों करता है, तो रेमैंडर अनुकूलन अत्यधिक सरल हो जाता हैं। यदि <code>रेमैंडरपॉलीनोमियल</code> मात्र n बिट लॉन्ग होता है, तो  इसके और <code>जनरेटरपॉलीनोमियल</code> के <math>x^n</math> गुणांक को सरलता से त्याग दिया जाता है। यही कारण है कि आप सामान्यतः सीआरसी पॉलीनोमियलों को बाइनरी में लिखे हुए देखेंगे, जिसमें प्रमुख गुणांक हटा दिया जाएगा।
-सॉफ़्टवेयर में, यह नोट करना सुविधाजनक है कि कोई भी देरी कर सकता है <code>xor</code> प्रत्येक बिट का अंतिम क्षण तक, इसे पहले करना भी संभव है। इसे निष्पादित करना आमतौर पर सुविधाजनक होता है <code>xor</code> एक समय में एक बाइट, यहां तक कि इस तरह से एक-एक बार कार्यान्वयन में भी:
+सॉफ्टवेयर में, यह नोट करना सुविधाजनक है कि जहां कोई प्रत्येक बिट के <code>xor</code> को अंतिम क्षण तक विलंबित कर सकता है, वहीं इसे फर्स्ट करना भी संभव है। <code>xor</code> को एक समय में एक बाइट निष्पादित करना आमतौर पर सुविधाजनक होता है, यहां तक कि इस तरह से एक बिट-ए-टाइम इम्प्लीमेंटेशन में भी:
-  फ़ंक्शन सीआरसी(''बाइट ऐरे'' स्ट्रिंग[1..लेन], ''इंट'' लेन) {
+  '''function''' crc(''byte array'' string[1..len], ''int'' len) {
-      शेषबहुपद := 0
+      remainderPolynomial := 0
-      ''// एक लोकप्रिय संस्करण यहां शेषबहुपद का पूरक है; देखना {{slink||Preset to −1}} below''
+      ''// A popular variant complements remainderPolynomial here; see {{slink||Preset to −1}} below''
       '''for''' i '''from''' 1 '''to''' len {
-          remainderPolynomial := remainderPolynomial '''xor''' '''polynomialForm'''(string[i]) * x<sup>n−8</sup>
+          remainderPolynomial := remainderPolynomial '''xor''' '''polynomialForm'''(string[i]) * x<sup>n−8</sup>
           '''for''' j '''from''' 1 '''to''' 8 {    ''// Assuming 8 bits per byte''
               '''if''' coefficient of ''x''<sup>n−1</sup> of remainderPolynomial = 1 {
-                  remainderPolynomial := (remainderPolynomial * ''x'') '''xor''' generatorPolynomial
+                  remainderPolynomial := (remainderPolynomial * ''x'') '''xor''' generatorPolynomial
               } '''else''' {
-                  remainderPolynomial := (remainderPolynomial * ''x'')
+                  remainderPolynomial := (remainderPolynomial * ''x'')
               }
           }
       }
       ''// A popular variant complements remainderPolynomial here; see {{slink||Post-invert}} below''
       '''return''' remainderPolynomial
   }
-:कोड खंड 3: बाइटवाइज मेसेज XORing के साथ बहुपद डिवीज़न
+:कोड फ्रेगमेंट 3: बाइटवाइज मेसेज XORing के साथ पॉलीनोमियल डिवीज़न
-यह आम तौर पर सबसे कॉम्पैक्ट सॉफ़्टवेयर कार्यान्वयन है, जिसका उपयोग [[माइक्रोकंट्रोलर्स]] में तब किया जाता है जब स्पेस प्रीमियम ओवर स्पीड पर होता है।
+यह सामान्यतः सबसे कॉम्पैक्ट सॉफ़्टवेयर इम्प्लीमेंटेशन होता है, जिसका उपयोग [[माइक्रोकंट्रोलर्स]] में तब किया जाता है जब स्पेस प्रीमियम ओवर स्पीड पर होता है।
 == बिट ऑर्डरिंग (एंडियननेस) ==
-जब [[बिट-सीरियल आर्किटेक्चर]] [[हार्डवेयर (कंप्यूटर)]] में प्रयुक्त किया जाता है, तो जनरेटर बहुपद विशिष्ट रूप से बिट असाइनमेंट का वर्णन करता है; प्रेषित पहला बिट हमेशा उच्चतम शक्ति का गुणांक होता है <math>x</math>, और आखरी बात <math>n</math> प्रेषित बिट्स सीआरसी शेष हैं <math>R(x)</math>, के गुणांक से प्रारंभ करते हुए <math>x^{n-1}</math> और के गुणांक के साथ समाप्त होता है <math>x^0</math>, अर्थात् 1 का गुणांक।
+जब [[बिट-सीरियल आर्किटेक्चर]] [[हार्डवेयर (कंप्यूटर)|हार्डवेयर]] में प्रयुक्त किया जाता है, तो जनरेटर पॉलीनोमियल विशिष्ट रूप से बिट असाइनमेंट का वर्णन करता है; ट्रांसमिटेड प्रथम बिट सदैव उच्चतम पॉवर का गुणांक <math>x</math> होता है, और लास्ट बात <math>n</math> ट्रांसमिटेड बिट्स सीआरसी रेमैंडर <math>R(x)</math> हैं , <math>x^{n-1}</math> के गुणांक से प्रारंभ करते हुए  और के <math>x^0</math> गुणांक के साथ समाप्त होता है, अर्थात् 1 का गुणांक होता है।
-हालाँकि, जब बिट्स को एक समय में एक बाइट संसाधित किया जाता है, जैसे कि समानांतर ट्रांसमिशन का उपयोग करते समय, 8बी/10बी एन्कोडिंग या आरएस-232-शैली एसिंक्रोनस सीरियल संचार के रूप में बाइट फ़्रेमिंग, या [[सॉफ़्टवेयर]] में सीआरसी प्रयुक्त करते समय, डेटा के बिट ऑर्डरिंग (एंडियननेस) को निर्दिष्ट करना आवश्यक है; प्रत्येक बाइट में कौन सा बिट पहले माना जाता है और उच्च शक्ति का गुणांक होगा <math>x</math>.
+यघपि, जब बिट्स को एक समय में एक बाइट संसाधित किया जाता है, जैसे कि समानांतर ट्रांसमिशन का उपयोग करते समय, 8बी/10बी एन्कोडिंग या आरएस-232-शैली एसिंक्रोनस सीरियल संचार के रूप में बाइट फ़्रेमिंग, या [[सॉफ़्टवेयर]] में सीआरसी प्रयुक्त करते समय, डेटा के बिट ऑर्डरिंग (एंडियननेस) को निर्दिष्ट करना आवश्यक होता है; प्रत्येक बाइट में कौन सा बिट "फर्स्ट" माना जाता है और उच्च पॉवर का गुणांक <math>x</math> होता है।
-यदि डेटा [[धारावाहिक संचार]] के लिए नियत है, तो बिट ऑर्डर का उपयोग करना सबसे अच्छा है जिससे डेटा अंततः भेजा जाएगा। ऐसा इसलिए है क्योंकि सीआरसी की [[विस्फोट त्रुटि]]यों का पता लगाने की क्षमता मेसेज बहुपद में निकटता पर आधारित है <math>M(x)</math>; यदि आसन्न बहुपद शब्दों को क्रमिक रूप से प्रसारित नहीं किया जाता है, तो बिट्स के पुनर्व्यवस्था के कारण एक लॉन्गई की भौतिक त्रुटि विस्फोट को लॉन्ग विस्फोट के रूप में देखा जा सकता है।
+यदि डेटा [[धारावाहिक संचार|सीरियल कम्युनिकेशनर]] के लिए नियत है, तो बिट ऑर्डर का उपयोग करना सबसे अच्छा है जिससे डेटा अंततः भेजा जाएगा। ऐसा इसलिए है क्योंकि सीआरसी की [[विस्फोट त्रुटि|बर्स्ट एरर]] का पता लगाने की क्षमता मेसेज पॉलीनोमियल <math>M(x)</math> में निकटता पर आधारित होती है ; यदि आसन्न पॉलीनोमियल शब्दों को क्रमिक रूप सेट्रांसमिट नहीं किया जाता है, तो बिट्स के पुनर्व्यवस्था के कारण एक भौतिक एरर बर्स्ट को लॉन्ग बर्स्ट के रूप में देखा जा सकता है।
-उदाहरण के लिए, [[आईईईई 802]] ([[ईथरनेट]]) और आरएस-232 ([[ आनुक्रमिक द्वार ]]) दोनों मानक कम से कम महत्वपूर्ण बिट पहले (लिटिल-एंडियन) ट्रांसमिशन को निर्दिष्ट करते हैं, इसलिए ऐसे लिंक पर भेजे गए डेटा की सुरक्षा के लिए एक सॉफ्टवेयर सीआरसी कार्यान्वयन को प्रत्येक बाइट में कम से कम महत्वपूर्ण बिट्स को उच्चतम शक्तियों के गुणांक में मैप करना चाहिए। <math>x</math>. दूसरी ओर, [[फ्लॉपी डिस्क]] और अधिकांश [[हार्ड ड्राइव]] पहले प्रत्येक बाइट का सबसे महत्वपूर्ण बिट लिखते हैं।
+उदाहरण के लिए, [[आईईईई 802]] ([[ईथरनेट]]) और आरएस-232 ([[ आनुक्रमिक द्वार |सीरियल पोर्ट]] ) दोनों मानक कम से कम महत्वपूर्ण बिट फर्स्ट (लिटिल-एंडियन) ट्रांसमिशन को निर्दिष्ट करते हैं, इसलिए ऐसे लिंक पर भेजे गए डेटा की सुरक्षा के लिए एक सॉफ्टवेयर सीआरसी इम्प्लीमेंटेशन को प्रत्येक बाइट में कम से कम महत्वपूर्ण बिट्स को उच्चतम पॉवरों के गुणांक <math>x</math> में मैप करना चाहिए। दूसरी ओर, [[फ्लॉपी डिस्क]] और अधिकांश [[हार्ड ड्राइव]] फर्स्ट प्रत्येक बाइट का सबसे महत्वपूर्ण बिट लिखते हैं।
-lsbit-first CRC को सॉफ़्टवेयर में प्रयुक्त करना थोड़ा आसान है, इसलिए इसे कुछ हद तक सामान्य रूप से देखा जाता है, लेकिन कई प्रोग्रामर MSbit-first बिट ऑर्डर का पालन करना आसान पाते हैं। इस प्रकार, उदाहरण के लिए, एक्सएमओडीईएम-सीआरसी एक्सटेंशन, सॉफ्टवेयर में सीआरसी का प्रारंभिक उपयोग, एमएसबिट-फर्स्ट सीआरसी का उपयोग करता है।
+एलएसबिट-फर्स्ट सीआरसी को सॉफ़्टवेयर में प्रयुक्त करना थोड़ा आसान होता है, इसलिए इसे कुछ हद तक सामान्य रूप से देखा जाता है, लेकिन कई प्रोग्रामर एमएसबिट-फर्स्ट बिट ऑर्डर का पालन करना आसान पाते हैं। इस प्रकार, उदाहरण के लिए, एक्सएमओडीईएम-सीआरसी एक्सटेंशन, सॉफ्टवेयर में सीआरसी का प्रारंभिक उपयोग, एमएसबिट-फर्स्ट सीआरसी का उपयोग करता है।
-अब तक, स्यूडोकोड ने स्यूडोकोड में बदलावों को गुणन के रूप में वर्णित करके बाइट्स के भीतर बिट्स के क्रम को निर्दिष्ट करने से परहेज किया है। <math>x</math> और द्विआधारी से बहुपद रूप में स्पष्ट रूपांतरण लिखना। व्यवहार में, सीआरसी को एक विशेष बिट-ऑर्डरिंग कन्वेंशन का उपयोग करके एक मानक बाइनरी रजिस्टर में रखा जाता है। एमएसबिट-फर्स्ट रूप में, सबसे महत्वपूर्ण बाइनरी बिट्स पहले भेजे जाएंगे और इसलिए इसमें उच्च-क्रम बहुपद गुणांक होंगे, जबकि एलएसबिट-फर्स्ट रूप में, कम से कम महत्वपूर्ण बाइनरी बिट्स में उच्च-क्रम गुणांक होंगे। उपरोक्त छद्म कोड दोनों रूपों में लिखा जा सकता है। ठोसता के लिए, यह 16-बिट CRC-16-[[CCITT]] बहुपद का उपयोग करता है <math>x^{16} + x^{12} + x^5 + 1</math>:
+अब तक, स्यूडोकोड ने स्यूडोकोड में बदलावों को गुणन के रूप में वर्णित करके बाइट्स के भीतर बिट्स के क्रम को निर्दिष्ट करने से बचता  है। <math>x</math> और द्विआधारी से पॉलीनोमियल रूप में स्पष्ट रूपांतरण लिखना। व्यवहार में, सीआरसी को एक विरेमैंडर बिट-ऑर्डरिंग कन्वेंशन का उपयोग करके एक मानक बाइनरी रजिस्टर में रखा जाता है। एमएसबिट-फर्स्ट रूप में, सबसे महत्वपूर्ण बाइनरी बिट्स फर्स्ट भेजे जाएंगे और इसलिए इसमें उच्च-क्रम पॉलीनोमियल गुणांक होंगे, जबकि एलएसबिट-फर्स्ट रूप में, कम से कम महत्वपूर्ण बाइनरी बिट्स में उच्च-क्रम गुणांक होंगे। उपरोक्त स्यूडोकोड दोनों रूपों में लिखा जा सकता है। कंसर्टर्नर्स के लिए, यह 16-बिट सीआरसी-16-[[CCITT]] पॉलीनोमियल <math>x^{16} + x^{12} + x^5 + 1</math> का उपयोग करता है।
-  // सबसे महत्वपूर्ण बिट पहले (बड़ा-एंडियन)
+  ''// Most significant bit first (big-endian)''
-  // x^16+x^12+x^5+1 = (1) 0001 0000 0010 0001 = 0x1021
+  ''// x^16+x^12+x^5+1 = (1) 0001 0000 0010 0001 = 0x1021''
-  'फ़ंक्शन' सीआरसी (बाइट सरणी स्ट्रिंग [1..लेन], इंट लेन) {
+  '''function''' crc(''byte array'' string[1..len], ''int'' len) {
-      रेम := 0
+      rem := 0
-      // एक लोकप्रिय संस्करण यहाँ रेम को पूरक करता है
+      ''// A popular variant complements rem here''
-      'के लिए' मैं 'से' 1 'तक' लेन {
+      '''for''' i '''from''' 1 '''to''' len {
-          रेम := रेम 'एक्सओआर' (स्ट्रिंग[आई] 'लेफ्टशिफ्ट' (एन-8)) // एन = 16 इस उदाहरण में
+          rem  := rem '''xor''' (string[i] '''leftShift''' (n-8))   ''// n = 16 in this example''
-          'for' j 'from' 1 'to' 8 {// प्रति बाइट 8 बिट्स मानते हुए
+          '''for''' j '''from''' 1 '''to''' 8 {   ''// Assuming 8 bits per byte''
-              'यदि' रेम 'और' 0x8000 {// यदि सबसे बायां (सबसे महत्वपूर्ण) बिट सेट है
+              '''if''' rem '''and''' 0x8000 {   ''// if leftmost (most significant) bit is set''
-                  रेम := (रेम 'लेफ्टशिफ्ट' 1) 'एक्सओआर' 0x1021
+                  rem  := (rem '''leftShift''' 1) '''xor''' 0x1021
-              } 'अन्य' {
+              } '''else''' {
-                  रेम := रेम 'लेफ्टशिफ्ट' 1
+                  rem  := rem '''leftShift''' 1
               }
-              रेम := रेम 'और' 0xffff // शेष को 16 बिट्स तक ट्रिम करें
+              rem  := rem '''and''' 0xffff      // Trim remainder to 16 bits
           }
       }
-      // एक लोकप्रिय संस्करण यहाँ रेम को पूरक करता है
+      ''// A popular variant complements rem here''
-      'वापसी' रेम
+      '''return''' rem
   }
-:'कोड खंड 4: शिफ्ट रजिस्टर आधारित प्रभाग, एमएसबी फर्स्ट'
+:'कोड फ्रेगमेंट 4: शिफ्ट रजिस्टर बेस्ड डिवीज़न, एमएसबी फर्स्ट
-  // सबसे कम महत्वपूर्ण बिट पहले (लिटिल-एंडियन)
+  ''// Least significant bit first (little-endian)''
-  // x^16+x^12+x^5+1 = 1000 0100 0000 1000 (1) = 0x8408
+  ''// x^16+x^12+x^5+1 = 1000 0100 0000 1000 (1) = 0x8408''
-  'फ़ंक्शन' सीआरसी (बाइट सरणी स्ट्रिंग [1..लेन], इंट लेन) {
+  '''function''' crc(''byte array'' string[1..len], ''int'' len) {
-      रेम := 0
+      rem  := 0
-      // एक लोकप्रिय संस्करण यहाँ रेम को पूरक करता है
+      ''// A popular variant complements rem here''
-      'के लिए' मैं 'से' 1 'तक' लेन {
+      '''for''' i '''from''' 1 '''to''' len {
-          रेम := रेम 'xor' स्ट्रिंग[i]
+          rem  := rem '''xor''' string[i]
-          'for' j 'from' 1 'to' 8 {// प्रति बाइट 8 बिट्स मानते हुए
+          '''for''' j '''from''' 1 '''to''' 8 {   ''// Assuming 8 bits per byte''
-              'अगर' रेम 'और' 0x0001 {// अगर सबसे दाहिना (सबसे महत्वपूर्ण) बिट सेट है
+              '''if''' rem '''and''' 0x0001 {   ''// if rightmost (most significant) bit is set''
-                  रेम := (रेम 'राइटशिफ्ट' 1) 'एक्सओआर' 0x8408
+                  rem  := (rem '''rightShift''' 1) '''xor''' 0x8408
-              } 'अन्य' {
+              } '''else''' {
-                  रेम := रेम 'राइटशिफ्ट' 1
+                  rem  := rem '''rightShift''' 1
               }
           }
       }
-      // एक लोकप्रिय संस्करण यहाँ रेम को पूरक करता है
+      ''// A popular variant complements rem here''
-      'वापसी' रेम
+      '''return''' rem
   }
-:'कोड खंड 5: शिफ्ट रजिस्टर आधारित प्रभाग, एलएसबी फर्स्ट'
+:कोड फ्रेगमेंट 5: शिफ्ट रजिस्टर बेस्ड डिवीज़न, एलएसबी फर्स्ट
+ध्यान दें कि एलएसबिट-फर्स्ट  फॉर्म शिफ्ट करने की आवश्यकता से बचाता है <code>string[i]</code> से फर्स्ट <code>xor</code>. किसी भी स्थिति में, सीआरसी के बाइट्स को उस क्रम में प्रसारित करना सुनिश्चित करें जो आपके चुने हुए बिट-ऑर्डरिंग कन्वेंशन के समरूप होता है।
-ध्यान दें कि lsbit-पहला फॉर्म शिफ्ट करने की आवश्यकता से बचाता है <code>string[i]</code> से पहले <code>xor</code>. किसी भी स्थिति में, सीआरसी के बाइट्स को उस क्रम में प्रसारित करना सुनिश्चित करें जो आपके चुने हुए बिट-ऑर्डरिंग सम्मेलन से मेल खाता हो।
+ध्यान दें कि एलएसबिट-फर्स्ट फॉर्म से <code>xor</code>हले स्ट्रिंग [i] को स्थानांतरित करने की आवश्यकता से बचाता है। किसी भी स्थिति में, सीआरसी के बाइट्स को उस क्रम में प्रसारित करना सुनिश्चित करें जो आपके चुने हुए बिट-ऑर्डरिंग कन्वेंशन के समरूप होता है।
 == मल्टी-बिट कंप्यूटिंग ==
-=== सरवटे एल्गोरिदम (एकल लुकअप तालिका) ===
+=== सरवटे एल्गोरिदम (एकल लुकअप टेबल) ===
-एक अन्य सामान्य अनुकूलन उच्चतम क्रम गुणांक द्वारा अनुक्रमित लुकअप तालिका का उपयोग करता है <code>rem</code> प्रति पुनरावृत्ति एक से अधिक बिट लाभांश संसाधित करना।<ref>{{cite journal |first=Dilip V. |last=Sarwate |title=टेबल लुक-अप के माध्यम से चक्रीय अतिरेक जांच की गणना|journal=[[Communications of the ACM]] |volume=31 |issue=8 |date=August 1998 |pages=1008–1013 |doi=10.1145/63030.63037|s2cid=5363350 |doi-access=free }}</ref> आमतौर पर, 256-एंट्री लुकअप टेबल का उपयोग किया जाता है, जो बाहरी लूप (ऊपर) की बॉडी को प्रतिस्थापित करता है <code>i</code>) साथ:
+एक अन्य सामान्य अनुकूलन प्रति पुनरावृत्ति एक से अधिक बिट लाभांश को संसाधित करने के लिए<code>रेम</code> के उच्चतम क्रम गुणांक द्वारा अनुक्रमित लुकअप टेबल का उपयोग करता है।<ref>{{cite journal |first=Dilip V. |last=Sarwate |title=टेबल लुक-अप के माध्यम से चक्रीय अतिरेक जांच की गणना|journal=[[Communications of the ACM]] |volume=31 |issue=8 |date=August 1998 |pages=1008–1013 |doi=10.1145/63030.63037|s2cid=5363350 |doi-access=free }}</ref> सामान्यतः, 256-एंट्री लुकअप टेबल का उपयोग किया जाता है, जो बाहरी लूप (<code>i</code>ऊपर) की बॉडी को प्रतिस्थापित करता है।
+ // Msbit-first
+ rem = (rem '''leftShift''' 8) '''xor''' big_endian_table[string[i] '''xor''' ((leftmost 8 bits of rem) '''rightShift''' (n-8))]
+ // Lsbit-first
-  // एमएसबिट-फर्स्ट
+  rem = (rem '''rightShift''' 8) '''xor''' little_endian_table[string[i] '''xor''' (rightmost 8 bits of rem)]
- रेम = (रेम लेफ्टशिफ्ट 8) xor big_endian_table[स्ट्रिंग[i] xor ((रेम के सबसे बाएं 8 बिट्स) राइटशिफ्ट (n-8))]
+:कोड फ्रेगमेंट 6: टेबल आधारित डिवीज़न  के कोर
- // एलएसबिट-फर्स्ट
- रेम = (रेम राइटशिफ्ट 8) xor tiny_endian_table[string[i] xor (रेम के सबसे दाएँ 8 बिट्स)]
-:कोड खंड 6: तालिका आधारित डिवीज़न  के कोर
-सबसे आम तौर पर सामने आने वाले सीआरसी एल्गोरिदम में से एक को सीआरसी-32 के रूप में जाना जाता है, जिसका उपयोग (अन्य के अलावा) ईथरनेट, [[एफडीडीआई]], ज़िप (फ़ाइल प्रारूप) और अन्य संग्रह प्रारूप, और पोर्टेबल नेटवर्क ग्राफिक्स [[छवि प्रारूप]] द्वारा किया जाता है। इसके बहुपद को msbit-first को 0x04C11DB7, या lsbit-first को 0xEDB88320 के रूप में लिखा जा सकता है। [[पोर्टेबल नेटवर्क ग्राफ़िक्स]] पर W3C वेबपेज में CRC-32 के C में एक संक्षिप्त और सरल तालिका-संचालित कार्यान्वयन के साथ एक परिशिष्ट शामिल है।<ref>{{cite web
+सबसे सामान्यतः सामने आने वाले सीआरसी एल्गोरिदम में से एक को सीआरसी-32 के रूप में जाना जाता है, जिसका उपयोग (अन्य के अलावा) ईथरनेट, [[एफडीडीआई]], ज़िप (फ़ाइल फॉर्मेट) और अन्य आर्काइव  फॉर्मेट, और पोर्टेबल नेटवर्क ग्राफिक्स [[छवि प्रारूप|इमेज फॉर्मेट]] द्वारा किया जाता है। इसके पॉलीनोमियल को एमएसबिट-फर्स्ट को 0x04C11DB7, या एलएसबिट-फर्स्ट को 0xEDB88320 के रूप में लिखा जा सकता है। [[पोर्टेबल नेटवर्क ग्राफ़िक्स]] पर W3C वेबपेज में सीआरसी-32 के C में एक संक्षिप्त और सरल टेबल-संचालित इम्प्लीमेंटेशन के साथ एक अपेंडिक्स सम्मलित होता है।<ref>{{cite web
 | url=https://www.w3.org/TR/PNG/#D-CRCAppendix
 | title=Portable Network Graphics (PNG) Specification (Second Edition): Annex D, Sample Cyclic Redundancy Code implementation
 | date=2003-11-10
 | publisher=[[W3C]]
-| access-date = 2016-02-16}}</ref> आप देखेंगे कि कोड यहां प्रस्तुत lsbit-first byte-at-a-timeस्यूडोकोड से मेल खाता है, और तालिका बिट-एट-ए-टाइम कोड का उपयोग करके बनाई गई है।
+| access-date = 2016-02-16}}</ref> आप देखेंगे कि कोड यहां प्रस्तुत एलएसबिट-फर्स्ट बिट-एट-ए-टाइम स्यूडोकोड के समरूप होता है, और टेबल बिट-एट-ए-टाइम कोड का उपयोग करके बनाई गई है।
--प्रविष्टि तालिका का उपयोग करना आमतौर पर सबसे सुविधाजनक होता है, लेकिन अन्य आकारों का उपयोग किया जा सकता है। छोटे माइक्रोकंट्रोलर में, एक समय में चार बिट्स को प्रोसेस करने के लिए 16-एंट्री टेबल का उपयोग करने से टेबल को छोटा रखते हुए उपयोगी गति में सुधार होता है। पर्याप्त भंडारण वाले कंप्यूटरों पर, a {{val|65536}}-एंट्री टेबल का उपयोग एक समय में 16 बिट्स को प्रोसेस करने के लिए किया जा सकता है।
+-प्रविष्टि टेबल का उपयोग करना सामान्यतः सबसे सुविधाजनक होता है, लेकिन अन्य आकारों का उपयोग किया जा सकता है। छोटे माइक्रोकंट्रोलर में, एक समय में चार बिट्स को प्रोसेस करने के लिए 16-एंट्री टेबल का उपयोग करने से टेबल को छोटा रखते हुए उपयोगी गति में सुधार होता है। पर्याप्त स्टोरेज  वाले कंप्यूटरों पर, a {{val|65536}}-एंट्री टेबल का उपयोग एक समय में 16 बिट्स को प्रोसेस करने के लिए किया जा सकता है।
-==== तालिकाएँ उत्पन्न करना ====
+==== टेबल जनरेट करना ====
-तालिकाएँ उत्पन्न करने वाला सॉफ़्टवेयर इतना छोटा और तेज़ है कि स्टोरेज से पूर्व-कंप्यूटिंग की गई तालिकाओं को लोड करने की तुलना में प्रोग्राम स्टार्टअप पर उनकी कंप्यूटिंग करना आमतौर पर तेज़ होता है। एक लोकप्रिय तकनीक 256 संभावित 8-बिट बाइट्स के सीआरसी उत्पन्न करने के लिए 256 बार बिट-ए-टाइम कोड का उपयोग करना है। हालाँकि, उस संपत्ति का लाभ उठाकर इसे महत्वपूर्ण रूप से अनुकूलित किया जा सकता है <code>table[i '''xor''' j] == table[i] '''xor''' table[j]</code>. मात्र दो की शक्तियों के अनुरूप तालिका प्रविष्टियों की सीधे कंप्यूटिंग करने की आवश्यकता है।
+टेबल उत्पन्न करने वाला सॉफ़्टवेयर इतना छोटा और तेज़ है कि स्टोरेज से पूर्व-कंप्यूटिंग की गई टेबलओं को लोड करने की तुलना में प्रोग्राम स्टार्टअप पर उनकी कंप्यूटिंग करना आमतौर पर तेज़ होता है। एक लोकप्रिय तकनीक 256 संभावित 8-बिट बाइट्स के सीआरसी उत्पन्न करने के लिए 256 बार बिट-ए-टाइम कोड का उपयोग करना है। हालाँकि, उस संपत्ति का लाभ उठाकर इसे महत्वपूर्ण रूप से अनुकूलित किया जा सकता है <code>table[i '''xor''' j] == table[i] '''xor''' table[j]</code>. मात्र दो की पॉवरयों के अनुरूप टेबल प्रविष्टियों की सीधे कंप्यूटिंग करने की आवश्यकता है।
-निम्नलिखित उदाहरण कोड में, <code>crc</code> का मान रखता है <code>table[i]</code>:
+निम्नलिखित उदाहरण कोड में, <code>सीआरसी</code> का मान रखता है <code>table[i]</code>:
-  big_endian_table[0] := 0
+  big_endian_table[0] := 0
-  crc := 0x8000 // एक 16-बिट बहुपद मानकर
+  crc := 0x8000 // ''Assuming a 16-bit polynomial''
-  मैं := 1
+  i := 1
-  'करना' {
+  '''do''' {
-      'अगर' सीआरसी 'और' 0x8000 {
+      '''if''' crc '''and''' 0x8000 {
-          सीआरसी := (सीआरसी 'लेफ्टशिफ्ट' 1) 'एक्सओआर' 0x1021 // सीआरसी बहुपद
+          crc := (crc '''leftShift''' 1) '''xor''' 0x1021 // ''The CRC polynomial''
-      } 'अन्य' {
+      } '''else''' {
-          सीआरसी := सीआरसी 'लेफ्टशिफ्ट' 1
+          crc := crc '''leftShift''' 1
       }
-      // सीआरसी big_endian_table[i] का मान है; j को पहले से आरंभ की गई प्रविष्टियों पर पुनरावृति करने दें
+      // crc ''is the value of'' big_endian_table[i]''; let'' j ''iterate over the already-initialized entries''
-      'के लिए' j 'से' 0 'से' i−1 {
+      '''for''' j '''from''' 0 '''to''' i−1 {
-          big_endian_table[i + j] := crc 'xor' big_endian_table[j];
+          big_endian_table[i + j] := crc '''xor''' big_endian_table[j];
       }
-      मैं := मैं 'लेफ्टशिफ्ट' 1
+      i := i '''leftshift''' 1
- } 'जबकि' मैं <256
-:'कोड खंड 7: बाइट-एट-ए-टाइम सीआरसी टेबल जनरेशन, एमएसबी पहले'
-  थोड़ा_एंडियन_टेबल[0] := 0
+  } '''while''' i < 256
-  सीआरसी := 1;
+:'कोड फ्रेगमेंट 7: बाइट-एट-ए-टाइम सीआरसी टेबल जनरेशन, एमएसबी फर्स्ट'
-  मैं := 128
-  'करना' {
+ little_endian_table[0] := 0
-      'अगर' सीआरसी 'और' 1 {
+  crc := 1;
-          सीआरसी := (सीआरसी 'राइटशिफ्ट' 1) 'एक्सओआर' 0x8408 // सीआरसी बहुपद
+  i := 128
-      } 'अन्य' {
+  '''do''' {
-          सीआरसी := सीआरसी 'राइटशिफ्ट' 1
+      '''if''' crc '''and''' 1 {
+          crc := (crc '''rightShift''' 1) '''xor''' 0x8408 // ''The CRC polynomial''
+      } '''else''' {
+          crc := crc '''rightShift''' 1
       }
-      // सीआरसी tiny_endian_table[i] का मान है; j को पहले से आरंभ की गई प्रविष्टियों पर पुनरावृति करने दें
+      // crc ''is the value of'' little_endian_table[i]''; let'' j ''iterate over the already-initialized entries''
-      'के लिए' जे 'से' 0 'से' 255 'द्वारा' 2 × आई {
+      '''for''' j '''from''' 0 '''to''' 255 '''by''' 2 × i {
-          लिटिल_एंडियन_टेबल[आई + जे] := सीआरसी 'एक्सओआर' लिटिल_एंडियन_टेबल[जे];
+          little_endian_table[i + j] := crc '''xor''' little_endian_table[j];
       }
-      i := मैं 'राइटशिफ्ट' 1
+      i := i '''rightshift''' 1
-  } 'जबकि' मैं > 0
-:'कोड खंड 8: बाइट-एट-ए-टाइम सीआरसी टेबल जनरेशन, एलएसबी पहले'
+  } '''while''' i > 0
+:'कोड फ्रेगमेंट 8: बाइट-एट-ए-टाइम सीआरसी टेबल जनरेशन, एलएसबी फर्स्ट'
-इन कोड नमूनों में, तालिका अनुक्रमणिका <code>i + j</code> के बराबर है <code>i '''xor''' j</code>; आप जो भी फॉर्म अधिक सुविधाजनक हो उसका उपयोग कर सकते हैं।
+इन कोड नमूनों में, टेबल अनुक्रमणिका <code>i + j</code> के बराबर है <code>i '''xor''' j</code>; आप जो भी फॉर्म अधिक सुविधाजनक हो उसका उपयोग कर सकते हैं।
 ==== सीआरसी-32 एल्गोरिथ्म ====
-यह सीआरसी के सीआरसी-32 संस्करण के लिए एक व्यावहारिक एल्गोरिदम है।<ref>{{cite web|url=https://msdn.microsoft.com/en-us/library/dd905031.aspx|title=[MS-ABS]: 32-Bit CRC Algorithm|website=msdn.microsoft.com|access-date=4 November 2017|archive-date=7 November 2017|archive-url=https://web.archive.org/web/20171107004846/https://msdn.microsoft.com/en-us/library/dd905031.aspx|url-status=live}}</ref> सीआरसीटेबल एक कंप्यूटिंग का [[संस्मरण]] है जिसे मेसेज के प्रत्येक बाइट के लिए दोहराया जाना होगा ({{section link|Computation of cyclic redundancy checks|Multi-bit computation}}).
+यह सीआरसी के सीआरसी-32 संस्करण के लिए एक व्यावहारिक एल्गोरिदम है।<ref>{{cite web|url=https://msdn.microsoft.com/en-us/library/dd905031.aspx|title=[MS-ABS]: 32-Bit CRC Algorithm|website=msdn.microsoft.com|access-date=4 November 2017|archive-date=7 November 2017|archive-url=https://web.archive.org/web/20171107004846/https://msdn.microsoft.com/en-us/library/dd905031.aspx|url-status=live}}</ref> सीआरसीटेबल एक कंप्यूटिंग का [[संस्मरण]] है जिसे मेसेज के प्रत्येक बाइट के लिए दोहराया जाना होगा ({{section link|Computation of cyclic redundancy checks|Multi-bit computation}}). <syntaxhighlight>
+Function CRC32
+   Input:
+      data:  Bytes     // Array of bytes
+   Output:
+      crc32: UInt32    // 32-bit unsigned CRC-32 value
+// Initialize CRC-32 to starting value
+crc32 ← 0xFFFFFFFF
- <स्पैन स्टाइल=रंग:हरा; >फ़ंक्शन CRC32
+for each byte in data do
-    <span style= रंग:नीला; >इनपुट:</span>
+   nLookupIndex ← (crc32 xor byte) and 0xFF
-       डेटा: बाइट्स <स्पैन शैली = रंग: हरा; >// बाइट्स की सरणी
+   crc32 ← (crc32 shr 8) xor CRCTable[nLookupIndex]  // CRCTable is an array of 256 32-bit constants
-    <span style= रंग:नीला; >आउटपुट:</span>
-       crc32: UInt32 <span style= रंग:हरा; >// 32-बिट अहस्ताक्षरित सीआरसी-32 मान</span><br>
+// Finalize the CRC-32 value by inverting all the bits
- <स्पैन स्टाइल=रंग:हरा; >// प्रारंभिक मूल्य पर CRC-32 प्रारंभ करें
+crc32 ← crc32 xor 0xFFFFFFFF
- crc32 ← 0xFFFFFFFF<br>
+return crc32
- <span style= रंग:नीला; >प्रत्येक</span> बाइट के लिए <span style= color:blue; >in</span> डेटा <span style= color:blue; >करें</span>
+</syntaxhighlight>
-    nLookupIndex ← (crc32 xor बाइट) और 0xFF
-    crc32 ← (crc32 shr 8) xor CRCTable[nLookupIndex] <span style= color:green; >// CRCTable 256 32-बिट स्थिरांकों की एक सरणी है</span><br>
- <स्पैन स्टाइल=रंग:हरा; >// सभी बिट्स को उल्टा करके CRC-32 मान को अंतिम रूप दें
- crc32 ← crc32 xor 0xFFFFFFFF
- <span style= रंग:नीला; >वापसी</span> crc32
@@ Line 341: / Line 358: @@
-=== एकाधिक तालिकाओं का उपयोग करके बाइट-स्लाइसिंग ===
+=== एकाधिक टेबलओं का उपयोग करके बाइट-स्लाइसिंग ===
 एक स्लाइस-बाय-एन (आमतौर पर सीआरसी32 के लिए स्लाइस-बाय-8; एन ≤ 64) एल्गोरिदम मौजूद है जो आमतौर पर सरवटे एल्गोरिदम की तुलना में प्रदर्शन को दोगुना या तिगुना कर देता है। एक समय में 8 बिट्स पढ़ने के बजाय, एल्गोरिदम एक समय में 8N बिट्स पढ़ता है। ऐसा करने से [[सुपरस्केलर]] प्रोसेसर पर प्रदर्शन अधिकतम हो जाता है।<ref>{{cite book |doi=10.1109/ISCC.2005.18 |url=https://static.aminer.org/pdf/PDF/000/432/446/a_systematic_approach_to_building_high_performance_software_based_crc.pdf |chapter=A Systematic Approach to Building High Performance Software-Based CRC Generators |title=10th IEEE Symposium on Computers and Communications (ISCC'05) |year=2005 |last1=Kounavis |first1=M.E. |last2=Berry |first2=F.L. |pages=855–862 |isbn=0-7695-2373-0 |s2cid=10308354 }}</ref><ref>{{cite journal |title=उच्च-प्रदर्शन सीआरसी पीढ़ी के लिए नवीन तालिका लुकअप-आधारित एल्गोरिदम|journal=IEEE Transactions on Computers |date=November 2008 |volume=57 |issue=11 |pages=1550–1560 |doi=10.1109/TC.2008.85 |first1=Frank L. |last1=Berry |first2=Michael E. |last2=Kounavis|s2cid=206624854 }}</ref><ref>{{cite tech report |title=High Octane CRC Generation with the Intel Slicing-by-8 Algorithm |publisher=[[Intel]] |url=http://download.intel.com:80/technology/comms/perfnet/download/slicing-by-8.pdf |archive-url=https://web.archive.org/web/20120722193753/http://download.intel.com/technology/comms/perfnet/download/slicing-by-8.pdf |archive-date=2012-07-22 |url-status=dead }}</ref><ref>{{Cite web|url=https://www.kernel.org/doc/Documentation/crc32.txt|title=सीआरसी गणना पर संक्षिप्त ट्यूटोरियल|work=The Linux Kernel Archives}}</ref>
 यह स्पष्ट नहीं है कि वास्तव में एल्गोरिदम का आविष्कार किसने किया था।<ref>{{cite web |title=Who invented the slicing-by-N CRC32 algorithm? |first=Abhijit |last=Menon-Sen |date=2017-01-20 |url=http://toroid.org/crc32-slicing-by-N-paper}}</ref>
-=== तालिका के बिना समानांतर कंप्यूटिंग ===
+=== टेबल के बिना समानांतर कंप्यूटिंग ===
-एक समय में किसी बाइट या शब्द का समानांतर अद्यतन बिना तालिका के भी स्पष्ट रूप से किया जा सकता है।<ref>{{cite newsgroup
+एक समय में किसी बाइट या शब्द का समानांतर अद्यतन बिना टेबल के भी स्पष्ट रूप से किया जा सकता है।<ref>{{cite newsgroup
    | title = Re: 8051 and CRC-CCITT
    | author = Jon Buller
@@ Line 354: / Line 371: @@
    | url = https://groups.google.com/d/msg/comp.arch.embedded/fvQ7yM5F6ys/3xcgqF3Kqc4J
    | access-date = 2016-02-16
-}}</ref> इसका उपयोग आमतौर पर हाई-स्पीड हार्डवेयर कार्यान्वयन में किया जाता है। प्रत्येक बिट के लिए 8 बिट्स को स्थानांतरित करने के बाद एक समीकरण हल किया जाता है। निम्नलिखित तालिकाएँ निम्नलिखित प्रतीकों का उपयोग करके कुछ सामान्य रूप से उपयोग किए जाने वाले बहुपदों के समीकरणों को सूचीबद्ध करती हैं:
+}}</ref> इसका उपयोग आमतौर पर हाई-स्पीड हार्डवेयर इम्प्लीमेंटेशन में किया जाता है। प्रत्येक बिट के लिए 8 बिट्स को स्थानांतरित करने के बाद एक समीकरण हल किया जाता है। निम्नलिखित टेबल निम्नलिखित प्रतीकों का उपयोग करके कुछ सामान्य रूप से उपयोग किए जाने वाले पॉलीनोमियलों के समीकरणों को सूचीबद्ध करती हैं:
 {| class="wikitable"
 |-
-| c<sub>i</sub> || CRC bit 7…0 (or 15…0) before update
+| c<sub>i</sub> || सीआरसी bit 7…0 (or 15…0) before update
 |-
-| r<sub>i</sub> || CRC bit 7…0 (or 15…0) after update
+| r<sub>i</sub> || सीआरसी bit 7…0 (or 15…0) after update
 |-
 | d<sub>i</sub> || input data bit 7…0
@@ Line 372: / Line 389: @@
 {| class="wikitable"
-|+ Bit-wise update equations for some CRC-8 polynomials after 8 bits have been shifted in
+|+ Bit-wise update equations for some सीआरसी-8 पॉलीनोमियलs after 8 bits have been shifted in
-! Polynomial:
+! पॉलीनोमियल:
-| (''x''<sup>7</sup> + ''x''<sup>3</sup> + 1) &times; ''x'' ''(left-shifted CRC-7-CCITT)''
+| (''x''<sup>7</sup> + ''x''<sup>3</sup> + 1) &times; ''x'' ''(left-shifted सीआरसी-7-CCITT)''
-| ''x''<sup>8</sup> + ''x''<sup>5</sup> + ''x''<sup>4</sup> + 1 ''(CRC-8-Dallas/Maxim)''
+| ''x''<sup>8</sup> + ''x''<sup>5</sup> + ''x''<sup>4</sup> + 1 ''(सीआरसी-8-Dallas/Maxim)''
 |-
 ! Coefficients:
@@ Line 425: / Line 442: @@
 {| class="wikitable"
-|+ Bit-wise update equations for some CRC-16 polynomials after 8 bits have been shifted in
+|+ Bit-wise update equations for some सीआरसी-16 पॉलीनोमियलs after 8 bits have been shifted in
-! Polynomial:
+! पॉलीनोमियल:
-| colspan="2" | ''x''<sup>16</sup> + ''x''<sup>12</sup> + ''x''<sup>5</sup> + 1 ''(CRC-16-CCITT)''
+| colspan="2" | ''x''<sup>16</sup> + ''x''<sup>12</sup> + ''x''<sup>5</sup> + 1 ''(सीआरसी-16-CCITT)''
-| colspan="2" | ''x''<sup>16</sup> + ''x''<sup>15</sup> + ''x''<sup>2</sup> + 1 ''(CRC-16-ANSI)''
+| colspan="2" | ''x''<sup>16</sup> + ''x''<sup>15</sup> + ''x''<sup>2</sup> + 1 ''(सीआरसी-16-ANSI)''
 |-
 ! Coefficients:
@@ Line 573: / Line 590: @@
 |}
-=== दो-स्टेपीय कंप्यूटिंग ===
+=== टू-स्टेपीय कंप्यूटिंग ===
-चूँकि CRC-32 बहुपद में बड़ी संख्या में पद होते हैं, एक समय में शेष बाइट की कंप्यूटिंग करते समय प्रत्येक बिट पिछले पुनरावृत्ति के कई बिट्स पर निर्भर करता है। बाइट-समानांतर हार्डवेयर कार्यान्वयन में इसके लिए मल्टीपल-इनपुट या कैस्केड XOR गेट्स की आवश्यकता होती है जो प्रसार विलंब को बढ़ाता है।
+चूँकि सीआरसी-32 पॉलीनोमियल में बड़ी संख्या में पद होते हैं, एक समय में रेमैंडर बाइट की कंप्यूटिंग करते समय प्रत्येक बिट पिछले पुनरावृत्ति के कई बिट्स पर निर्भर करता है। बाइट-समानांतर हार्डवेयर इम्प्लीमेंटेशन में इसके लिए मल्टीपल-इनपुट या कैस्केड XOR गेट्स की आवश्यकता होती है जो प्रसार विलंब को बढ़ाता है।
-कंप्यूटिंग गति को अधिकतम करने के लिए, 123-बिट शिफ्ट रजिस्टर के माध्यम से मेसेज को पारित करके एक मध्यवर्ती शेष की कंप्यूटिंग की जा सकती है। बहुपद मानक बहुपद का सावधानीपूर्वक चयनित गुणज है, जैसे कि पद (फीडबैक टैप) व्यापक रूप से दूरी पर हैं, और शेष का कोई भी बिट प्रति बाइट पुनरावृत्ति में एक बार से अधिक XORed नहीं है। इस प्रकार मात्र दो-इनपुट XOR गेट, सबसे तेज़ संभव, की आवश्यकता है। अंत में सीआरसी-32 शेष प्राप्त करने के लिए मध्यवर्ती शेष को दूसरी पाली रजिस्टर में मानक बहुपद द्वारा विभाजित किया जाता है।<ref name="glaise">{{cite journal
+कंप्यूटिंग गति को अधिकतम करने के लिए, 123-बिट शिफ्ट रजिस्टर के माध्यम से मेसेज को पारित करके एक मध्यवर्ती रेमैंडर की कंप्यूटिंग की जा सकती है। पॉलीनोमियल मानक पॉलीनोमियल का सावधानीपूर्वक चयनित गुणज होता है, जैसे कि पद (फीडबैक टैप) व्यापक रूप से दूरी पर हैं, और रेमैंडर का कोई भी बिट प्रति बाइट पुनरावृत्ति में एक बार से अधिक XORed नहीं होता है। इस प्रकार मात्र दो-इनपुट XOR गेट, सबसे तेज़ संभव, की आवश्यकता होती है। अंत में सीआरसी-32 रेमैंडर प्राप्त करने के लिए मध्यवर्ती रेमैंडर को दूसरी शिफ्ट रजिस्टर में मानक पॉलीनोमियल द्वारा विभाजित किया जाता है।<ref name="glaise">{{cite journal
 | last=Glaise
 | first=René J.
@@ Line 594: / Line 611: @@
 === ब्लॉकवार कंप्यूटिंग ===
-शेष की ब्लॉक-वार कंप्यूटिंग किसी भी सीआरसी बहुपद के लिए हार्डवेयर में राज्य अंतरिक्ष परिवर्तन मैट्रिक्स को गुणनखंडित करके की जा सकती है, जो शेष को दो सरल टोप्लिट्ज मैट्रिक्स में कंप्यूटिंग करने के लिए आवश्यक है।<ref>{{Cite journal |last=Das |first=Arindam |date=2022 |title=लुक-अप टेबल के स्थान पर फैक्टर्ड टोप्लिट्ज़ मैट्रिसेस का उपयोग करके चक्रीय रिडंडेंसी कोड की ब्लॉक-वार गणना|url=https://ieeexplore.ieee.org/document/9826414 |journal=IEEE Transactions on Computers |volume=72 |issue=4 |pages=1110–1121 |doi=10.1109/TC.2022.3189574 |s2cid=250472783 |issn=0018-9340}}</ref>
+रेमैंडर की ब्लॉक-वार कंप्यूटिंग किसी भी सीआरसी पॉलीनोमियल के लिए हार्डवेयर में राज्य अंतरिक्ष परिवर्तन मैट्रिक्स को गुणनफ्रेगमेंटित करके की जा सकती है, जो रेमैंडर को दो सरल टोप्लिट्ज मैट्रिक्स में कंप्यूटिंग करने के लिए आवश्यक है।<ref>{{Cite journal |last=Das |first=Arindam |date=2022 |title=लुक-अप टेबल के स्थान पर फैक्टर्ड टोप्लिट्ज़ मैट्रिसेस का उपयोग करके चक्रीय रिडंडेंसी कोड की ब्लॉक-वार गणना|url=https://ieeexplore.ieee.org/document/9826414 |journal=IEEE Transactions on Computers |volume=72 |issue=4 |pages=1110–1121 |doi=10.1109/TC.2022.3189574 |s2cid=250472783 |issn=0018-9340}}</ref>
 एक-पास चेकिंग
-किसी मेसेज में सीआरसी जोड़ते समय, प्रेषित सीआरसी को अलग करना, उसकी पुन: कंप्यूटिंग करना और प्रेषित सीआरसी के विरुद्ध पुन: संगणित मूल्य को सत्यापित करना संभव है। हालाँकि, आमतौर पर एक सरल तकनीक होती है
+किसी मेसेज में सीआरसी जोड़ते समय, ट्रांसमिटेड सीआरसी को अलग करना, उसकी पुन: कंप्यूटिंग करना और ट्रांसमिटेड सीआरसी के विरुद्ध पुन: संगणित मूल्य को सत्यापित करना संभव है। हालाँकि, आमतौर पर एक सरल तकनीक होती है
 हार्डवेयर में उपयोग किया जाता है।
@@ Line 609: / Line 626: @@
 and has been widely used in the telecommunication industry for long time."
 </ref>
-यह संभावना यही कारण है कि अधिकांश नेटवर्क प्रोटोकॉल जिनमें सीआरसी शामिल है, अंतिम सीमांकक से पहले ऐसा करते हैं; सीआरसी की जांच के लिए यह जानना जरूरी नहीं है कि पैकेट का अंत निकट है या नहीं।
+यह संभावना यही कारण है कि अधिकांश नेटवर्क प्रोटोकॉल जिनमें सीआरसी शामिल है, अंतिम सीमांकक से फर्स्ट ऐसा करते हैं; सीआरसी की जांच के लिए यह जानना जरूरी नहीं है कि पैकेट का अंत निकट है या नहीं।
 वास्तव में, कुछ प्रोटोकॉल सीआरसी का उपयोग अंतिम सीमांकक - सीआरसी-आधारित फ़्रेमिंग के रूप में करते हैं।
 == सीआरसी वेरिएंट ==
-व्यवहार में, अधिकांश मानक रजिस्टर को ऑल-वन पर प्रीसेट करने और ट्रांसमिशन से पहले सीआरसी को उल्टा करने को निर्दिष्ट करते हैं। इससे सीआरसी की परिवर्तित बिट्स का पता लगाने की क्षमता पर कोई प्रभाव नहीं पड़ता है, लेकिन यह मेसेज में जोड़े गए बिट्स को नोटिस करने की क्षमता देता है।
+व्यवहार में, अधिकांश मानक रजिस्टर को ऑल-वन पर प्रीसेट करने और ट्रांसमिशन से फर्स्ट सीआरसी को उल्टा करने को निर्दिष्ट करते हैं। इससे सीआरसी की परिवर्तित बिट्स का पता लगाने की क्षमता पर कोई प्रभाव नहीं पड़ता है, लेकिन यह मेसेज में जोड़े गए बिट्स को नोटिस करने की क्षमता देता है।
 === −1 === पर प्रीसेट
-सीआरसी का बुनियादी गणित उन मेसेजों को स्वीकार करता है (सही ढंग से प्रसारित माना जाता है) जिन्हें बहुपद के रूप में व्याख्या किए जाने पर, सीआरसी बहुपद का एक गुणक होता है। यदि कुछ अग्रणी 0 बिट्स को ऐसे मेसेज से जोड़ा जाता है, तो वे बहुपद के रूप में इसकी व्याख्या को नहीं बदलेंगे। यह इस तथ्य के समतुल्य है कि 0001 और 1 एक ही संख्या हैं।
+सीआरसी का बुनियादी गणित उन मेसेजों को स्वीकार करता है (सही ढंग से प्रसारित माना जाता है) जिन्हें पॉलीनोमियल के रूप में व्याख्या किए जाने पर, सीआरसी पॉलीनोमियल का एक गुणक होता है। यदि कुछ अग्रणी 0 बिट्स को ऐसे मेसेज से जोड़ा जाता है, तो वे पॉलीनोमियल के रूप में इसकी व्याख्या को नहीं बदलेंगे। यह इस तथ्य के समतुल्य है कि 0001 और 1 एक ही संख्या हैं।
-लेकिन यदि प्रेषित किया जा रहा मेसेज अग्रणी 0 बिट्स की परवाह करता है, तो ऐसे परिवर्तन का पता लगाने के लिए बुनियादी सीआरसी एल्गोरिदम की अक्षमता अवांछनीय है। यदि यह संभव है कि एक ट्रांसमिशन त्रुटि ऐसे बिट्स को जोड़ सकती है, तो एक सरल समाधान यह है कि प्रारम्भ करें <code>rem</code> शिफ्ट रजिस्टर को कुछ गैर-शून्य मान पर सेट किया गया; सुविधा के लिए, आमतौर पर ऑल-वन्स मान का उपयोग किया जाता है। यह गणितीय रूप से मेसेज के पहले एन बिट्स को पूरक करने (बाइनरी नोट) के बराबर है, जहां एन सीआरसी रजिस्टर में बिट्स की संख्या है।
+लेकिन यदि ट्रांसमिटेड किया जा रहा मेसेज अग्रणी 0 बिट्स की परवाह करता है, तो ऐसे परिवर्तन का पता लगाने के लिए बुनियादी सीआरसी एल्गोरिदम की अक्षमता अवांछनीय है। यदि यह संभव है कि एक ट्रांसमिशन त्रुटि ऐसे बिट्स को जोड़ सकती है, तो एक सरल समाधान यह है कि प्रारम्भ करें <code>rem</code> शिफ्ट रजिस्टर को कुछ गैर-शून्य मान पर सेट किया गया; सुविधा के लिए, आमतौर पर ऑल-वन्स मान का उपयोग किया जाता है। यह गणितीय रूप से मेसेज के फर्स्ट एन बिट्स को पूरक करने (बाइनरी नोट) के बराबर है, जहां एन सीआरसी रजिस्टर में बिट्स की संख्या है।
 यह सीआरसी निर्माण और जांच को किसी भी तरह से प्रभावित नहीं करता है, जब तक जनरेटर और चेकर दोनों समान प्रारंभिक मूल्य का उपयोग करते हैं। कोई भी गैर-शून्य प्रारंभिक मान काम करेगा, और कुछ मानक असामान्य मान निर्दिष्ट करते हैं,<ref>E.g. low-frequency RFID {{Citation
@@ Line 630: / Line 647: @@
 === पोस्ट-उलटा ===
-उसी प्रकार की त्रुटि मेसेज के अंत में हो सकती है, भले ही मेसेजों के अधिक सीमित सेट के साथ। किसी मेसेज में 0 बिट जोड़ना उसके बहुपद को x से गुणा करने के बराबर है, और यदि यह पहले CRC बहुपद का गुणज था, तो उस गुणन का परिणाम भी होगा। यह इस तथ्य के समतुल्य है कि, चूँकि 726, 11 का गुणज है, इसलिए 7260 भी है।
+उसी प्रकार की त्रुटि मेसेज के अंत में हो सकती है, भले ही मेसेजों के अधिक सीमित सेट के साथ। किसी मेसेज में 0 बिट जोड़ना उसके पॉलीनोमियल को x से गुणा करने के बराबर है, और यदि यह फर्स्ट सीआरसी पॉलीनोमियल का गुणज था, तो उस गुणन का परिणाम भी होगा। यह इस तथ्य के समतुल्य है कि, चूँकि 726, 11 का गुणज है, इसलिए 7260 भी है।
-एक समान समाधान मेसेज के अंत में प्रयुक्त किया जा सकता है, मेसेज में जोड़ने से पहले सीआरसी रजिस्टर को उल्टा कर दिया जा सकता है। फिर, कोई भी गैर-शून्य परिवर्तन करेगा; सभी बिट्स को उलटना (ऑल-वन्स पैटर्न के साथ XORing) सबसे आम है।
+एक समान समाधान मेसेज के अंत में प्रयुक्त किया जा सकता है, मेसेज में जोड़ने से फर्स्ट सीआरसी रजिस्टर को उल्टा कर दिया जा सकता है। फिर, कोई भी गैर-शून्य परिवर्तन करेगा; सभी बिट्स को उलटना (ऑल-वन्स पैटर्न के साथ XORing) सबसे आम है।
 इसका एक-पास सीआरसी जाँच पर प्रभाव पड़ता है: मेसेज सही होने पर शून्य का परिणाम उत्पन्न करने के बजाय, यह एक निश्चित गैर-शून्य परिणाम उत्पन्न करता है। (सटीक होने के लिए, परिणाम व्युत्क्रम पैटर्न का सीआरसी (गैर-शून्य प्रीसेट के बिना, लेकिन पोस्ट-इनवर्ट के साथ) है।) एक बार जब यह स्थिरांक प्राप्त हो जाता है (एक मनमाना मेसेज पर एक-पास सीआरसी उत्पन्न/चेक करके सबसे आसानी से), इसका उपयोग उसी सीआरसी एल्गोरिथ्म का उपयोग करके जांचे गए किसी भी अन्य मेसेज की प्योरता को सत्यापित करने के लिए सीधे किया जा सकता है।
@@ Line 640: / Line 657: @@
 * [[कोड सुधारने में त्रुटि]]
 * [[हैश फ़ंक्शंस की सूची]]
-* [[समता (दूरसंचार)]] बहुपद के साथ 1-बिट सीआरसी के बराबर है {{math|''x''+1}}.
+* [[समता (दूरसंचार)]] पॉलीनोमियल के साथ 1-बिट सीआरसी के बराबर है {{math|''x''+1}}.
 गैर-सीआरसी चेकसम

Anonymous

Search

चक्रीय अतिरेक जांच की गणना: Difference between revisions

Revision as of 22:31, 2 August 2023

उदाहरण

इम्प्लीमेंटेशन

बिट ऑर्डरिंग (एंडियननेस)

मल्टी-बिट कंप्यूटिंग

सरवटे एल्गोरिदम (एकल लुकअप टेबल)

टेबल जनरेट करना

सीआरसी-32 एल्गोरिथ्म

एकाधिक टेबलओं का उपयोग करके बाइट-स्लाइसिंग

टेबल के बिना समानांतर कंप्यूटिंग

टू-स्टेपीय कंप्यूटिंग

ब्लॉकवार कंप्यूटिंग

सीआरसी वेरिएंट

पोस्ट-उलटा

यह भी देखें

संदर्भ

बाहरी संबंध

Navigation

Wiki tools

Page tools

Other projects

Categories