Rust में घातांक: 2025 की सर्वोत्तम प्रथाएँ (Python नहीं)

«क्या Rust में सीधे a ** b लिख सकते हैं?» — आप पूछेंगे और… गलत होंगे

यदि आप Python से Rust में आए हैं, तो पहला झटका — ** ऑपरेटर का न होना है। दूसरा झटका — कंपाइलर टाइपों में ढील बर्दाश्त नहीं करता। तीसरा (सुखद) — Rust घातांक के लिए उपकरणों का एक पूरा शस्त्रागार प्रदान करता है, जिनमें से प्रत्येक किसी विशिष्ट कार्य के लिए तैयार किया गया है।

2025 में, जब Rust उच्च-लोड सिस्टम और embedded-डेवलपमेंट में C++ को पीछे छोड़ रहा है, तो सवाल «How to raise a number to a power?» (जिसने Stack Overflow पर हज़ारों व्यूज़ जुटाए) और भी प्रासंगिक हो गया है। आइए एक बार और हमेशा के लिए समझ लें: Rust में संख्याओं को सही, तेज़ और सुरक्षित तरीके से कैसे घातांकित करें।

Rust में ** ऑपरेटर क्यों नहीं है?

Rust एक सिस्टम भाषा है। यह ऑपरेटरों को «मौके पर» ओवरलोड करने की अनुमति नहीं देता (हालाँकि std::ops ट्रेट्स मौजूद हैं, लेकिन घातांक के लिए वे नहीं हैं)। इसके बजाय, डेवलपर्स ने मेथड-फंक्शन प्रस्तावित किए, जो ऑपरेशन के प्रकार को स्पष्ट रूप से बताते हैं। यह पूर्णांक घातांक और फ्लोटिंग अंकगणित के बीच भ्रम को समाप्त करता है।

मुख्य नियम: डेटा प्रकार के अनुसार मेथड चुनें। i32 को f64 घात में डालने की कोशिश न करें — कंपाइलर आपको नहीं समझेगा, और यदि समझ भी गया (कास्टिंग के माध्यम से), तो आप प्रदर्शन या सटीकता खोने का जोखिम उठाते हैं।

मेथड pow() — पूर्णांकों का राजा

i32, u64 और अन्य पूर्णांक प्रकारों के लिए सबसे लोकप्रिय तरीका:

fn main() {\n    let base: i32 = 5;\n    let exponent: u32 = 3;\n    let result = base.pow(exponent);\n    println!("5^3 = {}", result); // 125\n}

ध्यान दें: exponent हमेशा u32 (अहस्ताक्षरित) होना चाहिए। यह तार्किक है — पूर्णांकों के लिए घात ऋणात्मक नहीं हो सकती (अन्यथा आपको भिन्न मिलेगा)।

कब उपयोग करें: हमेशा पूर्णांक गणनाओं के लिए। यह तेज़ी से काम करता है, बिना आवंटन के, मशीन निर्देशों के स्तर पर।

यदि घात ऋणात्मक हो तो क्या होगा?

पूर्णांकों के लिए — कोई रास्ता नहीं। Rust पूर्णांक प्रकारों के लिए ऋणात्मक घातों का समर्थन नहीं करता, क्योंकि परिणाम भिन्नात्मक होगा। यदि आपको 2^-3 चाहिए — तो फ्लोटिंग पॉइंट संख्याओं पर जाएँ।

powi() — f64 और f32 के लिए आदर्श विकल्प

यह मेथड पूर्णांक घातांक (प्रकार i32) स्वीकार करता है, लेकिन फ्लोटिंग पॉइंट संख्याओं के साथ काम करता है:

fn main() {\n    let base: f64 = 2.0;\n    let result = base.powi(-3);\n    println!("2.0^-3 = {}", result); // 0.125\n\n    // सकारात्मक घात भी संभव है\n    let result2 = base.powi(10);\n    println!("2.0^10 = {}", result2); // 1024.0\n}

2025 की खास बात: powi() पूर्णांक घातांक के लिए अनुकूलित है। यह तेज़ घातांक एल्गोरिदम (exponentiation by squaring) का उपयोग करता है। यदि आपका घातांक स्थिरांक या पूर्णांक है, तो f64/f32 के लिए यह सबसे तेज़ तरीका है।

powf() — जब घात भी भिन्न हो

यदि आधार और घातांक दोनों फ्लोटिंग पॉइंट संख्याएँ हैं, तो powf() का उपयोग करें:

fn main() {\n    let base: f64 = 9.0;\n    let exponent: f64 = 0.5;\n    let result = base.powf(exponent);\n    println!("9.0^0.5 = {}", result); // 3.0 (वर्गमूल)\n\n    // जटिल मामला\n    let base2 = 2.0_f64;\n    let exp2 = 3.14_f64;\n    println!("2.0^3.14 = {}", base2.powf(exp2)); // ~8.815\n}

महत्वपूर्ण: powf() धीमी लेकिन सटीक गणितीय लाइब्रेरी (आमतौर पर libm या हार्डवेयर निर्देश) का उपयोग करता है। ग्राफिक्स या गेम के लिए, जहाँ गति महत्वपूर्ण है, powi() पर विचार करें।

क्रेट num — सर्व-उपयोगी सैनिक

2025 में, Rust पारिस्थितिकी तंत्र क्रेट num (और num-