CRC32 चेकसम की गणना कैसे की जाती है?

102

शायद मैं इसे देख नहीं रहा हूं, लेकिन CRC32 या तो अनावश्यक रूप से जटिल लगता है, या अपर्याप्त रूप से कहीं भी मुझे वेब पर मिल सकता है।

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

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

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

क्या CRC32 की गणना कैसे की जाती है, इसका एक सरल विवरण है?

मैंने सी में कोड बनाने का प्रयास किया कि तालिका कैसे बनती है:

for (i = 0; i < 256; i++)
{
    temp = i;

    for (j = 0; j < 8; j++)
    {
        if (temp & 1)
        {
            temp >>= 1;
            temp ^= 0xEDB88320;
        }
        else {temp >>= 1;}
    }
    testcrc[i] = temp;
}

लेकिन यह उन मूल्यों के साथ असंगत मूल्यों को उत्पन्न करता है जो मुझे इंटरनेट पर कहीं और मिले हैं। मैं उन मूल्यों का उपयोग कर सकता हूं जो मुझे ऑनलाइन मिले थे, लेकिन मैं समझना चाहता हूं कि वे कैसे बनाए गए थे।

इन अविश्वसनीय रूप से भ्रमित करने वाली संख्याओं को दूर करने में कोई मदद बहुत सराहना की जाएगी।

c checksum crc32

— aquanar
स्रोत

9

CRC32 तालिका बनाने के लिए आपका कोड सही प्रतीत होता है। आपके lsbit-first ( उलट ) CRC32 बहुपद को 0xEDB88320भी msbit-first ( सामान्य ) के रूप में लिखा जा सकता है 0x04C11DB7। क्या तालिका मान जो आपने कहीं और पाया वही सीआरसी बहुपद का उपयोग करके उत्पन्न किया गया?

— jschmier

1

@ jschmier हाय, मुझे लगता है कि Im इस आदमी से सवाल पूछने के पीछे एक कदम है? stackoverflow.com/questions/62168128/…

— ब्लूजेक

यदि कोई अन्य व्यक्ति "ए पीलेस गाइड टू सीआरसी एरर डिटेक्शन अल्गोरिद्म" को पढ़ने के लिए उत्सुक है, तो वह मूल URL ऊपर से जुड़ा हुआ है, लेकिन Google को आसानी से कई प्रतियाँ मिल जाती हैं, इनमें से एक है: zlib.net/crc_v3.txt

— Stéphane

114

CRC32 के लिए बहुपद है:

x ³² + x ²⁶ + x ²³ + x ²² + x ¹⁶ + x ¹² + x ¹¹ + x ¹⁰ + x ⁸ + x ⁷ + x ⁷ + x ⁵ + x ⁴ + x ² + x + 1

या हेक्स और बाइनरी में:

0x 01 04 C1 1D B7
1 0000 0100 1100 0001 0001 1101 1011 0111

उच्चतम शब्द (x ³² ) आमतौर पर स्पष्ट रूप से नहीं लिखा जाता है, इसलिए इसे उसी तरह से हेक्स में दर्शाया जा सकता है

0x 04 C1 1D B7

1s और 0s को गिनने के लिए स्वतंत्र महसूस करें, लेकिन आप पाएंगे कि वे बहुपद के साथ मेल खाते हैं, जहां 1बिट 0 (या पहली बिट) और xबिट 1 (या दूसरी बिट) है।

यह बहुपद क्यों है? क्योंकि एक मानक दिए गए बहुपद होने की आवश्यकता है और मानक IEEE 802.3 द्वारा निर्धारित किया गया था। इसके अलावा एक बहुपद को खोजना बहुत मुश्किल है जो विभिन्न बिट त्रुटियों को प्रभावी ढंग से पता लगाता है।

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

सीआरसी प्राइमर, अध्याय 5

इसे बेहतर ढंग से समझने के लिए, इस गुणन के बारे में सोचें:

(x^3 + x^2 + x^0)(x^3 + x^1 + x^0)
= (x^6 + x^4 + x^3
 + x^5 + x^3 + x^2
 + x^3 + x^1 + x^0)
= x^6 + x^5 + x^4 + 3*x^3 + x^2 + x^1 + x^0

यदि हम मान लेते हैं कि x का आधार 2 है तो हम प्राप्त करते हैं:

x^7 + x^3 + x^2 + x^1 + x^0

सीआरसी प्राइमर Chp.5

क्यों? क्योंकि 3x ^ 3 11x ^ 11 है (लेकिन हमें केवल 1 या 0 पूर्व अंक की आवश्यकता है) इसलिए हम आगे बढ़ते हैं:

=1x^110 + 1x^101 + 1x^100          + 11x^11 + 1x^10 + 1x^1 + x^0
=1x^110 + 1x^101 + 1x^100 + 1x^100 + 1x^11 + 1x^10 + 1x^1 + x^0
=1x^110 + 1x^101 + 1x^101          + 1x^11 + 1x^10 + 1x^1 + x^0
=1x^110 + 1x^110                   + 1x^11 + 1x^10 + 1x^1 + x^0
=1x^111                            + 1x^11 + 1x^10 + 1x^1 + x^0

लेकिन गणितज्ञों ने नियम बदल दिए ताकि यह मॉड 2 हो जाए। तो हमारा मूल समीकरण इस तरह दिखता है:

=( 1x^110 + 1x^101 + 1x^100 + 11x^11 + 1x^10 + 1x^1 + x^0 ) MOD 2
=( 1x^110 + 1x^101 + 1x^100 +  1x^11 + 1x^10 + 1x^1 + x^0 )
= x^6 + x^5 + x^4 + 3*x^3 + x^2 + x^1 + x^0 (or that original number we had)

मुझे पता है कि यह विश्वास की एक छलांग है लेकिन यह लाइन-प्रोग्रामर के रूप में मेरी क्षमता से परे है। यदि आप एक हार्ड-कोर सीएस-छात्र या इंजीनियर हैं तो मैं इसे तोड़ने की चुनौती देता हूं। इस विश्लेषण से सभी को लाभ होगा।

तो एक पूर्ण उदाहरण बाहर काम करने के लिए:

   Original message                : 1101011011
   Polynomial of (W)idth 4         :      10011
   Message after appending W zeros : 11010110110000

अब हम CRC अंकगणित का उपयोग करके पाली द्वारा संवर्धित संदेश को विभाजित करते हैं। यह पहले जैसा ही विभाजन है:

            1100001010 = Quotient (nobody cares about the quotient)
       _______________
10011 ) 11010110110000 = Augmented message (1101011011 + 0000)
=Poly   10011,,.,,....
        -----,,.,,....
         10011,.,,....
         10011,.,,....
         -----,.,,....
          00001.,,....
          00000.,,....
          -----.,,....
           00010,,....
           00000,,....
           -----,,....
            00101,....
            00000,....
            -----,....
             01011....
             00000....
             -----....
              10110...
              10011...
              -----...
               01010..
               00000..
               -----..
                10100.
                10011.
                -----.
                 01110
                 00000
                 -----
                  1110 = Remainder = THE CHECKSUM!!!!

विभाजन एक भागफल देता है, जिसे हम दूर फेंक देते हैं, और एक शेष, जो गणना की गई चेकसम है। इससे गणना समाप्त हो जाती है। आमतौर पर, चेकसम को फिर संदेश में जोड़ा जाता है और परिणाम प्रसारित होता है। इस स्थिति में ट्रांसमिशन होगा: 11010110111110।

सीआरसी प्राइमर, अध्याय 7

केवल 32-बिट संख्या को अपने भाजक के रूप में उपयोग करें और अपनी पूरी धारा को अपने लाभांश के रूप में उपयोग करें। भागफल बाहर फेंक दो और शेष रखो। अपने संदेश के अंत में शेष भाग लें और आपके पास CRC32 है।

औसत आदमी की समीक्षा:

         QUOTIENT
        ----------
DIVISOR ) DIVIDEND
                 = REMAINDER

पहले 32 बिट्स लें।
बिट्स शिफ्ट करें
यदि 32 बिट्स डिविसोर से कम हैं, तो चरण 2 पर जाएं।
DIVISOR द्वारा XOR 32 बिट्स। चरण 2 पर जाएं।

(ध्यान दें कि धारा को 32 बिट्स द्वारा विभाजित किया जाना चाहिए या इसे गद्देदार किया जाना चाहिए। उदाहरण के लिए, 8-बिट ANSI स्ट्रीम को गद्देदार करना होगा। धारा के अंत में भी विभाजन रुका हुआ है।)

— ilkkachu
स्रोत

13

अंत में "औसत गाय की समीक्षा" के लिए +1 - शायद इस अधिकार को शीर्ष पर ले जाने पर विचार करें - एक प्रकार का टीएल; DR: P

— aaronsnoswell

4

@abbridnature याद रखें कि हम बहुपद को विभाजित कर रहे हैं, न कि केवल द्विआधारी संख्या। हम "सामान्य" घटाव नहीं कर सकते क्योंकि हम $ x ^ n $ $ x ^ {n + 1} $ से "उधार" नहीं ले सकते; वे विभिन्न प्रकार की चीजें हैं। इसके अलावा, चूंकि बिट्स केवल 0 या 1 हैं, -1 भी क्या होगा? वास्तव में, हम क्षेत्र Z / 2Z $ में गुणांक वाले बहुपदों की अंगूठी में काम कर रहे हैं, जिसमें केवल दो तत्व हैं, 0 और 1, और जहाँ $ 1 + 1 = 0 $ है। ताबूतों को एक क्षेत्र में रखने से, फिर बहुपदों का निर्माण होता है जिसे यूक्लिडियन डोमेन कहा जाता है, जो मूल रूप से सिर्फ उसी चीज़ की अनुमति देता है जिसे हम पहले स्थान पर अच्छी तरह से परिभाषित करने की कोशिश कर रहे हैं।

— कैल्विकसी

6

बस स्पष्ट करने के लिए वास्तविक बहुपद 100000100110000010001110110110111 = 0x104C11DB7 है। MSB निहित है, लेकिन फिर भी इसे एक कार्यान्वयन में ध्यान में रखा जाना चाहिए। चूंकि यह हमेशा सेट किया जाएगा क्योंकि बहुपद 33 बिट लंबा होने की आवश्यकता है (इसलिए शेष 32 बिट लंबा हो सकता है) कुछ लोग एमएसबी को छोड़ देते हैं।

— फेलिप टी।

2

x^6 + x^5 + x^4 + 3*x^3 + x^2 + x^1 + x^0 ... If we assume x is base 2 then we get: x^7 + x^3 + x^2 + x^1 + x^0। यह नहीं है कि गणित कैसे काम करता है। बहुपद के गुणांक mod (2) या GF (2) होते हैं, x को अकेला छोड़ दिया जाता है, जिसके परिणामस्वरूप x ^ 6 + x ^ 5 + x ^ 4 + x ^ 3 + x ^ 2 + x ^ 1 + x ^ होते हैं। 0 (चूंकि 3 मॉड (2) = 1)। Tack the remainder on the end of your message- तकनीकी रूप से शेष को 0 बिट्स से घटाया जाता है जो संदेश में जोड़े गए थे, लेकिन चूंकि यह आधुनिक (2) गणित है, दोनों जोड़ और घटाना XOR के समान हैं, और शेष के साथ XOR'ed शून्य बिट समान है। शेष के रूप में।

— rcgldr

2

@MarcusJ - Why did you append four 0s though?- cr की गणना करने के लिए सॉफ्टवेयर एल्गोरिदम प्रभावी रूप से 0s को जोड़ देता है, भले ही यह स्पष्ट न हो। यदि लंबे हाथ विभाजन का उपयोग करके सीआरसी गणना दिखाते हैं, तो विभाजन उदाहरण के लिए 0 एस को सही ढंग से प्रकट होने के लिए जोड़ा जाना चाहिए।

— rcgldr

11

IEEE802.3, CRC-32 के लिए। पूरे संदेश को एक धारावाहिक बिट स्ट्रीम के रूप में सोचें, संदेश के अंत में 32 शून्य जोड़ें। इसके बाद, आप संदेश के सभी बाइट्स के बिट्स को उल्टा कर देंगे और पहले 32 बिट्स के 1 पूरक का काम करेंगे। अब CRC-32 बहुपद, 0x104C11DB7 से विभाजित करें। अंत में, आपको इस डिवीज़न के 32-बिट शेष के 4 के बाइट्स में से प्रत्येक के बिट-रिवर्स के 1 को पूरक होना चाहिए। यह 32-बिट CRC बन जाता है जिसे संदेश के अंत में जोड़ा जाता है।

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

— पावलो बोब्रेक
स्रोत

2

यह अब तक का सबसे अच्छा जवाब है, हालांकि मैं '4-बाइट्स में से प्रत्येक को बिट-रिवर्स' की जगह 'बिट-रिवर्स 4 बाइट्स' के साथ एक इकाई के रूप में मानता हूं 'जैसे' abcdefgh ijklmnop qststuvwx yzABCDEF 'FEDCBAzy xwvutsrq' ponmlkji hgfedcba '। इसे भी देखें: CRC-32 हैश ट्यूटोरियल - ऑटोहॉटकी कम्युनिटी ।

— vafylec

1

नमस्ते, क्या "संदेश" सटीक है? क्या आप उल्टा करते हैं? stackoverflow.com/questions/62168128/…

— ब्लूजेक

10

एक सीआरसी बहुत सरल है; आप एक बहुपद का प्रतिनिधित्व बिट्स और डेटा के रूप में करते हैं, और बहुपद को डेटा में विभाजित करते हैं (या आप एक बहुपद के रूप में डेटा का प्रतिनिधित्व करते हैं और वही काम करते हैं)। शेष, जो 0 के बीच है और बहुपद CRC है। आपका कोड समझना थोड़ा कठिन है, आंशिक रूप से क्योंकि यह अधूरा है: अस्थायी और टेस्टस्कैन घोषित नहीं है, इसलिए यह स्पष्ट नहीं है कि क्या अनुक्रमित किया जा रहा है, और एल्गोरिथ्म के माध्यम से कितना डेटा चल रहा है।

सीआरसी को समझने का तरीका यह है कि एक छोटे बहुपद के साथ डेटा के एक छोटे टुकड़े (16 बिट्स या तो) का उपयोग करके कुछ गणना करने की कोशिश की जाए - 4 बिट्स, शायद। यदि आप इस तरह से अभ्यास करते हैं, तो आप वास्तव में समझ जाएंगे कि आप इसे कैसे कोडित कर सकते हैं।

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

— बवंडर
स्रोत

1

CRC32 या CRC32b के लिए, क्या हमें दो अलग-अलग स्ट्रिंग्स के लिए हैश टक्कर का अर्थ मिलता है, क्या हम एक ही CRC प्राप्त करते हैं

— indianwebdevil

1

नमस्ते, Im थोड़ा उलझन में है कि आप "डेटा में बहुपद" का क्या मतलब है? stackoverflow.com/questions/62168128/… बहुपद में X क्या है? क्या मैं चकर से ओट बाइट्स का उपयोग करता हूं?

— नीलाजेक

7

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

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

^{* पीडीएफ लिंक

सीआरसी उल्टा - सिद्धांत और व्यवहार।

एचयू बर्लिन पब्लिक रिपोर्ट

SAR-PR-2006-05

मई 2006

लेखक:

मार्टिन स्टिग्गे, हेनरिक प्लॉट, वुल्फ म्यूलर, जेन्स-पीटर रेडलिच}

— jschmier
स्रोत

नमस्ते, क्या आप थोड़ा विस्तार कर सकते हैं?

— ब्लूजैके

7

मैंने इस प्रश्न के उत्तर को उजागर करने की कोशिश में कुछ समय बिताया, और मैंने आखिरकार आज CRC-32 पर एक ट्यूटोरियल प्रकाशित किया: CRC-32 हैश ट्यूटोरियल - ऑटोहॉटकी कम्युनिटी

इस उदाहरण से, मैं ASCII स्ट्रिंग 'abc' के लिए CRC-32 हैश की गणना करने का तरीका प्रदर्शित करता हूं:

calculate the CRC-32 hash for the ASCII string 'abc':

inputs:
dividend: binary for 'abc': 0b011000010110001001100011 = 0x616263
polynomial: 0b100000100110000010001110110110111 = 0x104C11DB7

011000010110001001100011
reverse bits in each byte:
100001100100011011000110
append 32 0 bits:
10000110010001101100011000000000000000000000000000000000
XOR the first 4 bytes with 0xFFFFFFFF:
01111001101110010011100111111111000000000000000000000000

'CRC division':
01111001101110010011100111111111000000000000000000000000
 100000100110000010001110110110111
 ---------------------------------
  111000100010010111111010010010110
  100000100110000010001110110110111
  ---------------------------------
   110000001000101011101001001000010
   100000100110000010001110110110111
   ---------------------------------
    100001011101010011001111111101010
    100000100110000010001110110110111
    ---------------------------------
         111101101000100000100101110100000
         100000100110000010001110110110111
         ---------------------------------
          111010011101000101010110000101110
          100000100110000010001110110110111
          ---------------------------------
           110101110110001110110001100110010
           100000100110000010001110110110111
           ---------------------------------
            101010100000011001111110100001010
            100000100110000010001110110110111
            ---------------------------------
              101000011001101111000001011110100
              100000100110000010001110110110111
              ---------------------------------
                100011111110110100111110100001100
                100000100110000010001110110110111
                ---------------------------------
                    110110001101101100000101110110000
                    100000100110000010001110110110111
                    ---------------------------------
                     101101010111011100010110000001110
                     100000100110000010001110110110111
                     ---------------------------------
                       110111000101111001100011011100100
                       100000100110000010001110110110111
                       ---------------------------------
                        10111100011111011101101101010011

remainder: 0b10111100011111011101101101010011 = 0xBC7DDB53
XOR the remainder with 0xFFFFFFFF:
0b01000011100000100010010010101100 = 0x438224AC
reverse bits:
0b00110101001001000100000111000010 = 0x352441C2

thus the CRC-32 hash for the ASCII string 'abc' is 0x352441C2

— vafylec
स्रोत

1

यदि आप अधिक गति चाहते हैं, तो 2006 में इंटेल के बारे में कुछ इंजीनियरों द्वारा मशीन के डेटा चौड़ाई के 4 या 8 बाइट्स का उपयोग करके एक विधि द्वारा काम किया गया था। शैक्षणिक पेपर: static.aminer.org/pdf/PDF/000/432/446/… प्रोजेक्ट ऑन सोर्सफोर्ज: sourceforge.net/projects/slicing-by-8 सामान्य crc पेज: create.sthan-brumme.com/crc32

— एलन कोरी

1

हाय धन्यवाद बहुत अच्छा लग रहा है, लेकिन आप वास्तव में बहुपद मूल्य कैसे प्राप्त करते हैं? X वास्तव में क्या दर्शाता है? और जब यह x ^ 32 कहता है, तो क्या वह x 32 की शक्ति या बिटवाइज़ ऑपरेटर है ^? stackoverflow.com/questions/62168128/…

— ब्लूजाइक

1

फिर हमेशा रोसेटा कोड होता है, जो दर्जनों कंप्यूटर भाषाओं में लागू crc32 दिखाता है। https://rosettacode.org/wiki/CRC-32 और कई स्पष्टीकरण और कार्यान्वयन के लिंक हैं।

— चमकाओ
स्रोत

1

क्या आप थोड़ा विस्तार कर सकते हैं? stackoverflow.com/questions/62168128/…

— ब्लूजेक

1

करने के लिए आप की जरूरत है अनुस्मारक लेने के लिए crc32 को कम करने के लिए:

प्रत्येक बाइट पर बिट्स को उल्टा करें
Xx पहले चार बाइट्स 0xFF के साथ (यह प्रमुख 0 पर त्रुटियों से बचने के लिए है)
अंत में पैडिंग जोड़ें (यह अंतिम 4 बाइट्स हैश में भाग लेना है)
अनुस्मारक की गणना करें
बिट्स को फिर से उल्टा करें
फिर से परिणाम के लिए।

कोड में यह है:


func CRC32 (file []byte) uint32 {
    for i , v := range(file) {
        file[i] = bits.Reverse8(v)
    }
    for i := 0; i < 4; i++ {
        file[i] ^= 0xFF
    }

    // Add padding
    file = append(file, []byte{0, 0, 0, 0}...)
    newReminder := bits.Reverse32(reminderIEEE(file))

    return newReminder ^ 0xFFFFFFFF
}

जहाँ अनुस्मारक अनुस्मारक GF (2) [x] पर शुद्ध अनुस्मारक है

— गेब्रियल फुरस्टेनहेम
स्रोत

1

यह समझने में परेशानी का एक बिट (उद्देश्य का उद्देश्य) कर रहा हूँ? stackoverflow.com/questions/62168128/…

— ब्लूजेक

1

hey @bluejayke, इस लाइब्रेरी की जाँच करें github.com/furstenheim/sparse_crc32/blob/master/main.go यह स्पार्स फ़ाइलों के लिए crc32 को लागू करता है, आप देख सकते हैं कि कम्प्यूटेशन पर किटी की बारीकियों का विवरण है। यह अनुकूलित नहीं है इसलिए सामान्य कार्यान्वयन की तुलना में इसका पालन करना आसान है। यह हो सकता है कि आप जो नहीं समझते हैं वह GF (2) [x] भाग है। आमतौर पर x ^ 3 + x का मतलब 1010, x ^ 4 + x + 1 का मतलब 10011 है। तब आपको विभाजन करने की आवश्यकता है, उदाहरण के लिए x ^ 3 + x x * (x ^ 2 + 1) है। इसलिए x ^ 3 + x over x का रिमाइंडर 0 है, लेकिन x ^ 2 के ऊपर यह x ^ 2 * x + x होगा, यानी रिमाइंडर x होगा।

— गेब्रियल फुरस्टेनहेम

1

@bluejayke और reminderIEEE का अर्थ है एक प्रसिद्ध बहुपद के खिलाफ अनुस्मारक, IEEE बहुपद

— गेब्रियल फुरस्टेनहेम

हाय फिर, आपकी प्रतिक्रिया के लिए धन्यवाद। मैं सिर्फ (जावास्क्रिप्ट उद्देश्यों के लिए) समझने की कोशिश कर रहा हूं कि बहुपद में "x" रिपीनेट क्या है। क्या "x" कुछ ऐसी चीज़ों के लिए कोड-वर्ड है जो मैं यहाँ याद कर रहा हूँ? वहाँ शर्तों का एक बहुत कुछ है जो मुझे यहाँ भ्रमित करता है, मैंने पहले कभी CRC32 के बारे में नहीं सुना है, और खोज के बाद भी मुझे यह वास्तव में समझाया गया नहीं मिला। उदाहरण के लिए एक पीएनजी के लिए यह कहता है कि मुझे "प्रत्येक चंक के लिए सीआरसी" लेने की आवश्यकता है, क्या इसका मतलब "चुंक में सभी डेटा के लिए" है? लेकिन मैं बहुपद में "प्लग इन" कैसे करूं? "X" क्या दर्शाता है? इसके अलावा जब यह x ^ 32 कहता है, तो क्या यह Math.pow (x, 32) या बिटवाइज़ की तरह है

— ब्लूजेक

1

हाय @bluejayke, एक्स अभिकलन आसान बनाने के लिए एक अमूर्त है। यह किसी भी चीज द्वारा प्रतिस्थापित किए जाने की उम्मीद नहीं है। x ^ 2 का अर्थ है x * x, एक औपचारिक गुणन के रूप में। यहां chrisballance.com/wp-content/uploads/2015/10/CRC-Primer.html आप उस डिवीजन का एक अच्छा विवरण पा सकते हैं। मैंने अपने उत्तर के साथ जो कोशिश की, वह विभाजन (उस कड़ी में) और वास्तविक गणना के बीच का अंतर भरने के लिए थी

— गेब्रियल फुरस्टेनहेम