Rust में मॉड्यूल: remainder से भ्रमित न हों

परिचय: मॉड्यूल का सवाल इतना लोकप्रिय क्यों है?

अगर आपने कभी Rust में कोड लिखा है और नेगेटिव नंबरों के साथ काम किया है, तो आपने ज़रूर सोचा होगा: "मॉड्यूल फंक्शन कहाँ है?" Stack Overflow पर इस सवाल के हज़ारों व्यूज़ हैं, और यह कोई संयोग नहीं है। दरअसल, Rust में % ऑपरेटर modulus नहीं, बल्कि remainder (शेषफल) है। यह अंतर बहुत छोटा है, लेकिन एल्गोरिदम, क्रिप्टोग्राफी या साइक्लिक स्ट्रक्चर के साथ काम करते समय यह बेहद महत्वपूर्ण हो जाता है।

इस लेख में हम समझेंगे कि गणितीय मॉड्यूल और remainder में क्या अंतर है, Rust नेगेटिव नंबरों को कैसे हैंडल करता है, और आप अपना खुद का सही मॉड्यूल फंक्शन कैसे लिख सकते हैं। यह लेख शुरुआती लोगों के लिए है, लेकिन अनुभवी डेवलपर्स भी अपनी जानकारी ताज़ा कर सकते हैं।

लेख की मुख्य बातें

\n
• मॉड्यूल और remainder: गणितीय अंतर
\n
• Rust में % modulus क्यों नहीं है
\n
• Rust में मॉड्यूल फंक्शन कैसे लिखें
\n
• वास्तविक जीवन के उदाहरण: साइक्लिक इंडेक्स और हैश
\n
• निष्कर्ष और व्यावहारिक सुझाव
\n

गणित: मॉड्यूल बनाम remainder

चलिए बुनियादी बातों से शुरू करते हैं। गणित में मॉड्यूल (modulus) एक ऐसा ऑपरेशन है जो हमेशा एक नॉन-नेगेटिव नंबर लौटाता है, जो डिवाइडर से छोटा होता है। उदाहरण के लिए:

\n
• 7 mod 3 = 1 (7 को 3 से भाग देने पर शेष 1)
\n
• -7 mod 3 = 2 (क्योंकि -7 = 3 * (-3) + 2)
\n

Remainder (शेषफल) वह है जो इंटीजर डिवीज़न के बाद बचता है। ज़्यादातर प्रोग्रामिंग भाषाओं (C, C++, Java, Rust) में % ऑपरेटर remainder लौटाता है, जो नेगेटिव हो सकता है अगर डिविडेंड नेगेटिव हो। उदाहरण:

\n
• 7 % 3 = 1 (समान)
\n
• -7 % 3 = -1 (Rust में, क्योंकि -7 / 3 = -2, remainder -1)
\n

यह क्यों ज़रूरी है? मान लीजिए आप एक घड़ी का प्रोग्राम लिख रहे हैं: समय 0–23। अगर अभी 22 बजे हैं और आप 5 घंटे जोड़ते हैं, तो सुबह के 3 बजेंगे। यह मॉड्यूल के साथ काम करता है: (22 + 5) mod 24 = 3। लेकिन अगर आप remainder का उपयोग करेंगे, तो नेगेटिव वैल्यू के साथ सब कुछ गड़बड़ हो जाएगा। उदाहरण के लिए, Rust में (-3) % 24 का परिणाम -3 होगा, 21 नहीं।

Rust में % ऑपरेटर remainder क्यों है

Rust में % ऑपरेटर को remainder के रूप में परिभाषित किया गया है। यह डॉक्यूमेंटेशन और स्टैंडर्ड लाइब्रेरी के व्यवहार में स्पष्ट है। इसका कारण ऐतिहासिक है: C और कई अन्य भाषाओं में ऐसा ही किया गया है। Rust "एक्सप्लिसिट बेटर दैन इम्प्लिसिट" के सिद्धांत का पालन करता है, लेकिन यहाँ शुरुआती अक्सर गलती कर बैठते हैं।

fn main() {\n    println!("7 % 3 = {}", 7 % 3);   // 1\n    println!("-7 % 3 = {}", -7 % 3); // -1\n    println!("7 % -3 = {}", 7 % -3); // 1 (हाँ, डिवाइडर का चिह्न प्रभावित नहीं करता)\n    println!("-7 % -3 = {}", -7 % -3); // -1\n}

ध्यान दें: परिणाम का चिह्न हमेशा डिविडेंड के चिह्न के समान होता है। यह मॉड्यूल नहीं है। सही मॉड्यूल के लिए, परिणाम हमेशा नॉन-नेगेटिव होना चाहिए।

Rust में सही मॉड्यूल फंक्शन कैसे लिखें?

Rust की स्टैंडर्ड लाइब्रेरी में मॉड्यूल के लिए कोई बिल्ट-इन फंक्शन नहीं है (Python के विपरीत, जहाँ % मॉड्यूल की तरह काम करता है)। लेकिन इसे लिखना बहुत आसान है। यहाँ सबसे सामान्य तरीका है — remainder को सही करके।

इंटीजर के लिए modulus फंक्शन

fn modulus(a: i32, b: i32) -> i32 {\n    let r = a % b;\n    if r < 0 { r + b.abs() } else { r }\n}\n\nfn main() {\n    println!("modulus(7, 3) = {}", modulus(7, 3));   // 1\n    println!("modulus(-7, 3) = {}", modulus(-7, 3)); // 2\n    println!("modulus(7, -3) = {}", modulus(7, -3)); // 1 (मॉड्यूल हमेशा नॉन-नेगेटिव)\n    println!("modulus(-7, -3) = {}", modulus(-7, -3)); // 2\n}

यह कैसे काम करता है: हम पहले remainder a % b निकालते हैं। अगर यह नेगेटिव है, तो हम इसमें b का एब्सोल्यूट वैल्यू जोड़ देते हैं।