👨🏾‍🤝‍👨🏻 🍲 🕎 Microsoft लंबा अंकगणित 👋🏾 🛌🏼 🎷

परिचय

यह ज्ञात है कि एक कंप्यूटर उन संख्याओं के साथ काम कर सकता है जिनकी संख्या सीमित है। एक नियम के रूप में, हम 32-बिट और 64-बिट पूर्णांक के साथ काम करने के लिए उपयोग किए जाते हैं, जो .NET प्लेटफॉर्म पर क्रमशः Int32 (int) और Int64 (long) प्रकार के अनुरूप हैं।

और क्या करना है अगर आपको किसी संख्या की कल्पना करने की आवश्यकता है, जैसे कि, 29! = 884176199373970195954361616000000? ऐसी संख्या 64-बिट में फिट नहीं होगी, 32-बिट डेटा प्रकार से बहुत कम है। यह इतनी बड़ी संख्या के साथ काम करने के लिए है कि एक लंबी अंकगणित है।

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

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

संस्करण 4.0 तक .NET प्लेटफ़ॉर्म में लंबी संख्या के साथ काम करने के लिए अंतर्निहित समर्थन नहीं था। 4 वें संस्करण में, .NET ने न केवल लंबे समय तक, बल्कि जटिल संख्याओं का भी अधिग्रहण किया। यह कार्यक्षमता System.Numerics असेंबली के माध्यम से उपलब्ध है और BigInteger और Complex प्रकार को असेंबली के समान नाम के नामस्थान में परिभाषित किया गया है।

यह कहा जाना चाहिए कि BigInteger संरचना .NET 3.5 में दिखाई देने वाली थी, लेकिन उस समय यह पूरी तरह से तैयार नहीं थी, इसका कार्यान्वयन सभी आवश्यकताओं को पूरा नहीं करता था (प्रदर्शन समस्याओं को इसके लिए जिम्मेदार ठहराया जा सकता था), इसलिए इसे .NET से बाहर निकलने का निर्णय लिया गया था। 4.0।

इस लेख में, मैं Microsoft से लंबी अंकगणित के कार्यान्वयन के विवरण पर विचार करना चाहूंगा।

सामान्य अवधारणाएँ

कंप्यूटर मेमोरी में लंबी संख्या का प्रतिनिधित्व करने का विचार काफी सरल है। दशमलव संख्या प्रणाली में संख्या 123456789 पर विचार करें। जाहिर है, यह निम्नानुसार प्रतिनिधित्व किया जा सकता है:

123456789 ₁₀ = 1 * 10 ⁸ + 2 * 10 ⁷ + 3 * 10 ⁶ + 4 * 10 ⁵ + 5 * 10 ⁴ + 6 * 10 ³ + 7 * 10 ² + 8 * 10 ¹ + 9 * 10 ⁰

सामान्य तौर पर, किसी भी संख्या को निम्न रूप में दर्शाया जा सकता है:

A = a _n-1- ^n-1 + a _{-2 2} ^n-2 + ... + ₁ ₀ + _{0 0}
जहाँ where उस संख्या प्रणाली का आधार है जिसमें हम संख्या का प्रतिनिधित्व करते हैं, और गुणांक _i , दोहरी असमानता को संतुष्ट करता है 0 equ a _i <base।

एक संख्या का प्रतिनिधित्व एक बहुपद के प्रतिनिधित्व की याद दिलाता है, केवल x के बजाय उपयुक्त डिग्री के लिए हमारे पास आवश्यक डिग्री के लिए आधार is है। जैसा कि ज्ञात है, बहुपद का प्रतिनिधित्व करना सुविधाजनक है ₀ + ₁ x ₁ + ₂ x ² + ... + एक _n x ⁿ एक सरणी के रूप में जिनके तत्व गुणांक _{i का} प्रतिनिधित्व करते हैं, और सूचकांक I संबंधित डिग्री x निर्धारित करता है। लंबी संख्या समान रूप से संग्रहीत की जाती है, यह आधार of की पसंद निर्धारित करने के लिए बनी हुई है।

उदाहरण के लिए, एक ही संख्या 123456789 को दस हजारवें (β = 10 ⁴ ) संख्या प्रणाली में निम्न प्रकार से दर्शाया जा सकता है:

123456789 ₁₀ = 1 * (10 ⁴ ) ² + 2345 * (10 ⁴ ) ¹ + 6789 * (10 ⁴ ) ⁰

दस-हज़ार की संख्या प्रणाली में संख्या 123456789 का प्रतिनिधित्व करते हुए, हमें एक ही बार में दो लाभ मिलते हैं: सबसे पहले, हम उपभोग की गई मेमोरी की मात्रा को कम करते हैं, क्योंकि 9 संख्याओं की एक सरणी के बजाय यह 3 संख्याओं (1, 2345 और 6789) की एक सरणी को संग्रहीत करने के लिए पर्याप्त है, और दूसरी बात, काफी। हम लंबी संख्या पर मानक संचालन के निष्पादन समय को कम करते हैं, क्योंकि हम एक समय में किसी संख्या के 4 अंकों को संसाधित करते हैं। सामान्य तौर पर, एक कंप्यूटर एक-बिट और 32-बिट संख्याओं को समान रूप से जल्दी से जोड़ता है, इसलिए आपको इसका उपयोग करना चाहिए।

संख्या प्रणाली का आधार depends आमतौर पर कंप्यूटर पर आधार डेटा प्रकार के अधिकतम आकार पर निर्भर करता है, और निम्न विचारों के आधार पर चुना जाता है:

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

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

Microsoft से BigInteger

यदि आप रिफ्लेक्टर या dotPeek डिकंपाइलर के माध्यम से BigInteger संरचना को देखते हैं, तो आपको निम्नलिखित फ़ील्ड दिखाई देंगे:

private static readonly BigInteger s_bnMinInt = new BigInteger(-1, new uint[1]{ (uint) int.MinValue }); private static readonly BigInteger s_bnOneInt = new BigInteger(1); private static readonly BigInteger s_bnZeroInt = new BigInteger(0); private static readonly BigInteger s_bnMinusOneInt = new BigInteger(-1); internal int _sign; internal uint[] _bits; private const int knMaskHighBit = -2147483648; private const uint kuMaskHighBit = 2147483648U; private const int kcbitUint = 32; private const int kcbitUlong = 64; private const int DecimalScaleFactorMask = 16711680; private const int DecimalSignMask = -2147483648;

संरचना में केवल दो उदाहरण फ़ील्ड (_sign और _bits) हैं, शेष फ़ील्ड स्थिरांक और स्थिर रीड फ़ील्ड हैं जो संख्या -1, 0 और 1 के लिए संरचना मानों का प्रतिनिधित्व करते हैं।

हम मान सकते हैं कि संख्या का चिह्न चर _sign में संग्रहीत है, और _bits सरणी में गुणांक _{i है} । यह देखते हुए कि _bits सरणी uint [] की है, हम यह भी मान सकते हैं कि β का आधार दो 2 ³² की शक्ति के रूप में लिया जाता है (क्योंकि uint एक 32-बिट अहस्ताक्षरित संख्या है)।

इसलिए, हम अपनी मान्यताओं की पुष्टि या खंडन करने का प्रयास करते हैं।

एक कंस्ट्रक्टर जो एक इंट लेता है वह एक तर्क के रूप में दिखता है:

इंट्रस्टक को स्वीकार करने वाला कंस्ट्रक्टर

 public BigInteger(int value) { if (value == int.MinValue) { this = BigInteger.s_bnMinInt; } else { this._sign = value; this._bits = (uint[]) null; } }

इसका कार्यान्वयन _sign चर के उद्देश्य के बारे में थोड़ा और बता सकता है। जैसा कि आप देख सकते हैं, यदि एक लंबी संख्या को इंट रेंज (-2 ³¹ से 2 ³¹ -1 तक) में रखा गया है, तो इसे _sign वेरिएबल में संग्रहीत किया जाता है, और _bits सरणी का उपयोग नहीं किया जाता है, यह शून्य है। इस अनुकूलन को बिगइंटर प्रकार के काम को गति देना चाहिए, साथ ही खपत की गई मेमोरी के आकार को कम करना चाहिए जब संख्या वास्तव में बड़ी नहीं होती है।

आगे बढ़ो।

एक कंस्ट्रक्टर जो एक तर्क के रूप में यूंट लेता है वह इस तरह दिखता है:

कंस्ट्रक्टर होस्ट उंट

 public BigInteger(uint value) { if (value <= (uint) int.MaxValue) { this._sign = (int) value; this._bits = (uint[]) null; } else { this._sign = 1; this._bits = new uint[1]; this._bits[0] = value; } }

संख्या को इंट रेंज में रखा गया है या नहीं, इस पर निर्भर करते हुए, यह या तो _sign चर या _bits सरणी में लिखा जाता है।

निम्नलिखित निर्माता, एक 64-बिट हस्ताक्षरित संख्या (लंबी) को स्वीकार करते हुए, संख्या प्रणाली के आधार को चुनने के बारे में प्रश्न का उत्तर देने में मदद करेगा:

कंस्ट्रक्टर मेजबान लंबे

 public BigInteger(long value) { if ((long) int.MinValue <= value && value <= (long) int.MaxValue) { if (value == (long) int.MinValue) { this = BigInteger.s_bnMinInt; } else { this._sign = (int) value; this._bits = (uint[]) null; } } else { ulong num; if (value < 0L) { num = (ulong) -value; this._sign = -1; } else { num = (ulong) value; this._sign = 1; } this._bits = new uint[2]; this._bits[0] = (uint) num; this._bits[1] = (uint) (num >> 32); } }

यदि संख्या इंट रेंज में फिट नहीं होती है, तो, जैसा कि हम देखते हैं, _sign चर में संख्या का चिह्न होता है (नकारात्मक के लिए -1 और सकारात्मक के लिए 1), और _bit सरणी में समान गुणांक _{i होता है} और इसे निम्न प्रकार से भरा जाता है।

 this._bits = new uint[2]; this._bits[0] = (uint) num; this._bits[1] = (uint) (num >> 32);

इस स्थिति में, 64-बिट संख्या संख्या को दो 32-बिट संख्याओं में विभाजित किया जाता है: (uint) संख्या और (uint) (संख्या >> 32)। पहली संख्या पिछले 32 बिट्स की संख्या है, जबकि दूसरी पहली 32 बिट्स है (एन बिट्स के दाईं ओर स्थानांतरण 2 पूर्णांक द्वारा पूर्णांक विभाजन के बराबर है)।

आइए निर्धारित करते हैं कि बिग लॉन्ग स्ट्रक्चर में नंबर लॉन्ग.मैक्सवैल्यू = 2 ⁶³ -1 = 9223372036854775807 कैसे स्टोर किया जाएगा। ऐसा करने के लिए, इसे 2 ^{32 से} विभाजित करें:

असल में (uint) long.MaxValue = 4294967295, (uint) (long.MaxValue >> 32) = 2147483647।

तो, 9223372036854775807 = 2147483647 * (2 ³² ) ¹ + 4294967295 * (2 ³² ) ⁰ , और BigInteger
एक जोड़ी द्वारा प्रतिनिधित्व किया जाएगा:

_साइन = 1
_bits = {4294967295, 2147483647} // याद रखें कि संख्या पीछे की ओर संग्रहीत है

एक लंबी संख्या -123456789101112131415151617181920 हमारे पास है:

अर्थात्, संख्या 2 ³² की शक्तियों में इस प्रकार विस्तारित है:
1234567891011121314151617181920 = 15 * (2 ³² ) ³ + 2501550035 * (2 ³² ) ² + 3243814879 * (2 ³² ) ¹ + 4035623136 * (2 ³² ) ⁰

तो BigInteger को एक जोड़ी द्वारा दर्शाया जाएगा:

_sign = -1 // संख्या का चिह्न
_bit = {4035623136, 3243814879, 2501550035, 15}

एक संख्या, जो एक अंतर श्रेणी में फिट होती है, कहती है, 17 इस प्रकार संग्रहीत की जाएगी:

_साइन = 17
_बिट्स = अशक्त

BigInteger संरचना के निर्माणकर्ताओं की जांच करने के बाद , हम निष्कर्ष निकाल सकते हैं:

यदि संख्या को अंतर सीमा में रखा जाता है, तो इसे चर _sign में संग्रहीत किया जाता है;
यदि संख्या इंट रेंज में फिट नहीं होती है, तो इसका चिन्ह चर _sign (नकारात्मक के लिए -1 और सकारात्मक के लिए 1) में संग्रहीत किया जाता है, और _bits सरणी में गुणांक 2 2 के आधार के साथ लंबी संख्या _के विस्तार का एक _i होता है।

आधार it = 2 ³² एक अच्छा विकल्प है, क्योंकि निम्न स्तर पर दो की शक्ति के साथ काम करना आसान है (दो की शक्ति से गुणा करना और विभाजित करना थोड़ा बाएं और दाएं पारियों से मेल खाती है), और संख्या के 32 अंकों को एक समय में संसाधित किया जाएगा, जो तेजी से पर्याप्त अनुमति देता है उन पर कार्रवाई करते हैं।

सामान्य तौर पर, BigInteger संरचना .NET प्लेटफॉर्म पर लंबी अंकगणित का पूर्ण-कार्यान्वयन है। उसी समय, Microsoft ने इसे आदिम संख्यात्मक प्रकारों के जितना संभव हो उतना करीब लाने की कोशिश की: एक BigInteger उदाहरण को किसी अन्य पूर्णांक प्रकार के रूप में उपयोग किया जा सकता है। BigInteger बुनियादी गणितीय संक्रियाओं को अधिभारित करता है, जैसे कि जोड़, घटाव, विभाजन, गुणन, घटाव, ऋणात्मक और एकात्मक नकार जैसे बुनियादी गणितीय कार्य। आप एक दूसरे के साथ दो BigInteger मानों की तुलना करने के लिए मानक संख्यात्मक ऑपरेटरों का भी उपयोग कर सकते हैं। अन्य प्रकार के पूर्णांक की तरह, BigInteger बिट संचालकों का समर्थन करता है और, या, XOR, बाएं शिफ्ट और राइट शिफ्ट।

उपयोगकर्ता-परिभाषित ऑपरेटरों का समर्थन नहीं करने वाली भाषाओं के लिए, BigInteger संरचना गणितीय संचालन करने के लिए समान तरीके प्रदान करती है। यह Add, Divide, Multiply, Negate, Subtract और कुछ अन्य तरीकों पर लागू होता है। Microsoft ने दशमलव ढांचे को लागू करने में ठीक वैसा ही किया।

BigInteger संरचना के कई सदस्य सीधे अन्य पूर्णांक प्रकारों के सदस्यों से मेल खाते हैं। इसके अलावा, BigInteger ऐसे तत्व जोड़ता है:

IsEven - यह निर्धारित करता है कि क्या संख्या सम है;
IsPowerOfTwo - यह निर्धारित करता है कि संख्या दो की शक्ति है या नहीं;
साइन - बिगइन्टेगर संख्या का संकेत दर्शाता एक मान;
Abs - BigInteger संख्या का पूर्ण मान लौटाता है;
DivRem - भागफल और शेष बचे विभाजन ऑपरेशन;
GreatestCommonDivisor - दो नंबर के लिए सबसे बड़ा सामान्य भाजक लौटाता है;
लॉग - निर्दिष्ट आधार के साथ संख्या प्रणाली में निर्दिष्ट संख्या का लघुगणक लौटाता है;
अधिकतम / न्यूनतम - दो संख्याओं में से सबसे बड़ा / सबसे छोटा;
ModPow - एक संख्या के मॉड्यूलर विभाजन को दूसरी संख्या की शक्ति तक बढ़ाता है;
पॉव - बिगइंटर का मान निर्दिष्ट डिग्री तक बढ़ा देता है।

मोनो और जावा में BigInteger के बारे में कुछ शब्द

यह ध्यान दिया जाना चाहिए कि मोनो के पास लंबे अंकगणित के लिए भी समर्थन है। मोनो में BigInteger संरचना का कार्यान्वयन व्यावहारिक रूप से Microsoft कार्यान्वयन से अलग नहीं है, सिवाय इसके कि इसमें इंट द्वारा दर्शाए गए संख्याओं के लिए अनुकूलन नहीं है।

यही है, मोनो में नंबर 17 को एक जोड़ी द्वारा दर्शाया जाएगा:

_sign = 1 // संख्या का चिन्ह
_बिट्स = {17}

BigInteger का एक समान कार्यान्वयन जावा में प्रस्तुत किया गया है:

 public class BigInteger extends Number implements Comparable<BigInteger> { int signum; int[] mag; private int bitCount = -1; private int bitLength = -1; private int lowestSetBit = -2; private int firstNonzeroByteNum = -2; private int firstNonzeroIntNum = -2; private final static long LONG_MASK = 0xffffffffL; }

चूंकि जावा में अहस्ताक्षरित प्रकार नहीं हैं, इसलिए मैग् सरणी टाइप int [] का है। तदनुसार, जावा और .NET में एक लंबी संख्या का प्रतिनिधित्व अलग होगा। .NET में, प्रस्तुति थोड़ी अधिक कुशल होगी क्योंकि यूंट प्रकार एक बड़ी सीमा तक फैला है:

कंस्ट्रक्टर मेजबान लंबे

 private BigInteger(long val) { if (val < 0) { signum = -1; val = -val; } else { signum = 1; } int highWord = (int)(val >>> 32); if (highWord == 0) { mag = new int[1]; mag[0] = (int)val; } else { mag = new int[2]; mag[0] = highWord; mag[1] = (int)val; } }

जावा में, साथ ही मोनो में, इंट द्वारा दर्शाए गए संख्याओं के लिए कोई अनुकूलन नहीं है।

बड़ा प्रदर्शन

जब एक बड़ी BigInteger संख्या के साथ काम करते हैं, तो आपको संभावित प्रदर्शन के मुद्दों के बारे में पता होना चाहिए। उदाहरण के लिए, प्रतीत होता है हानिरहित ऑपरेटर ++ प्रदर्शन पर महत्वपूर्ण प्रभाव डाल सकता है:

 int length = 1000000; BigInteger num = BigInteger.Parse("12345678910111213141516171819"); for (int i = 2; i < length; i++) { if (IsPrime(i)) num++; } Console.WriteLine(num);

हालांकि ऐसा लगता है कि इस उदाहरण में किसी मौजूदा वस्तु का मूल्य बदल जाता है, यह नहीं है। BigInteger ऑब्जेक्ट अपरिवर्तनीय हैं, अर्थात, आंतरिक रूप से, सामान्य भाषा रनटाइम वास्तव में एक नया BigInteger ऑब्जेक्ट बनाता है और इसे पिछले एक से अधिक मान देता है।

इस उदाहरण में, आप निम्न कार्य कर सकते हैं: नियमित रूप से संख्यात्मक प्रकारों का उपयोग करके मध्यवर्ती संचालन करें, और फिर BigInteger का उपयोग करें:

 int length = 1000000; BigInteger num = BigInteger.Parse("12345678910111213141516171819"); int temp = 0; for (int i = 2; i < length; i++) { if (IsPrime(i)) temp++; } num += temp; Console.WriteLine(num);

अन्य .NET फ्रेमवर्क संख्यात्मक प्रकार भी अपरिवर्तनीय हैं। हालाँकि, चूंकि BigInteger प्रकार का ऊपरी या निचला बाउंड नहीं है, इसलिए इसका मान बहुत बड़े मानों तक बढ़ सकता है और प्रदर्शन पर एक औसत दर्जे का प्रभाव डाल सकता है।

एक निष्कर्ष के बजाय

सारांशित करते हुए, हम कह सकते हैं कि .NET प्लेटफ़ॉर्म, जो संस्करण 4 से शुरू होता है, ने पूर्णांक लंबे अंकगणित के पूर्ण कार्यान्वयन का अधिग्रहण किया है। शायद, पूरी खुशी के लिए, यह BigRational संरचना को लागू करने के लिए बना हुआ है, जो लंबे समय से .NET BCL में बीटा स्थिति में मौजूद है।

BigRational संरचना का विवरण: BigRational संरचना BigInteger प्रकार पर आधारित है, जिसे .NET फ्रेमवर्क 4 में पेश किया गया था और आपको मनमानी परिशुद्धता के तर्कसंगत संख्या बनाने की अनुमति देता है। एक परिमेय संख्या दो पूर्णांकों का अनुपात है, और BigRational संरचना के इस कार्यान्वयन में, BigInteger प्रकार का उपयोग लाभांश (अंशदाता) और भाजक (भाजक) के रूप में किया जाता है।

टिप्पणी के लिए धन्यवाद: गौरांगा