पर्ल मॉड्यूल में अनंतता की जांच करने का सबसे अच्छा तरीका क्या है?

Question

मेरे मॉड्यूल में से एक में, मुझे अनंतता की अवधारणा से निपटना होगा। आज तक, मैं 9**9**9 का उपयोग सकारात्मक अनंतता के रूप में कर रहा हूं, और यह अच्छी तरह से काम करता प्रतीत होता है, तेज़ है, और ऐसा लगता है कि पर्ल के आंतरिक इंफिनिटी के रूप में क्या उपयोग करते हैं।

हालांकि, चीज़ें थोड़ी dicey मिल मेरी मॉड्यूल का एक उपयोगकर्ता बड़ी संख्या मॉड्यूल में से एक (जैसे use bigint;) का उपयोग करने का फैसला करता है, और फिर वे inf या Math::BigInt->binf() का उपयोग अनंत प्रतिनिधित्व करने के लिए।

कुछ स्थानों पर यह ठीक काम करता प्रतीत होता है, लेकिन दूसरों में, तुलना जो सत्य होनी चाहिए या गलत तरीके से झूठ बोलना चाहिए, जिससे बग को ट्रैक करना मुश्किल हो जाता है।

मैं कुछ ऐसी चीजों के साथ अनंतता के विभिन्न अन्य विचारों का समर्थन करना चाहता हूं जो सामान्य पीआरएल संख्याओं और मनमाने ढंग से सटीक संख्या दोनों के साथ काम करेंगे।

लेकिन मुझे प्रदर्शन के बारे में भी चिंता है क्योंकि मेरी कुछ तुलना अनंतता के लिए आंतरिक आंतरिक लूप में होती है। स्पष्ट रूप से Math::BigInt9**9**9 से धीमा होने जा रहा है (या तो प्रत्येक पहुंच पर बंधे या ओवरलोड किए गए तरीकों को कॉल करने के कारण)। क्या किसी ने अतीत में इस समस्या का सामना किया है? यदि हां, तो आपका समाधान क्या था?

मैं कुछ इस तरह परिभाषित किया गया अनंत के लिए अपने खुद के निरंतर उपयोग करते हुए, के बारे में सोचा है:

use constant INF => if_any_bignum_modules_loaded() 
        ? Math::BigInt->binf 
        : 9**9**9; 

और फिर है कि किसी भी bignum मॉड्यूल पहले लोड किया जाना चाहिए मेरी मॉड्यूल को चेतावनी जोड़ने। क्या यह ध्वनि समझदार है? क्या वहां if_any_bignum... का विश्वसनीय कार्यान्वयन है, या क्या मुझे अपना खुद का रोल करना चाहिए?

Answer 1

Math::BigIntis_inf विधि प्रदान करता है। यह पर्ल के अंतर्निर्मित inf, जैसे 9**9**9, साथ ही किसी भी प्रकार के Math::Big* उदाहरण या bigint का उपयोग करते समय प्राप्त होने वाली जादू की चीज़ों सहित नियमित पर्ल संख्याओं के लिए अनंतता का पता लगा सकता है। वैसे भी bigint उपयोग करने के लिए कोई भी तुलनीय - - लोड हो रहा है Math::BigInt बिल्कुल मुश्किल से किसी भी भूमि के ऊपर के साथ आता है और पर्ल 5.

use 5.010; 
use Math::BigInt; 

say Math::BigInt->is_inf(42); 
say Math::BigInt->is_inf(9**9**9); 
say Math::BigInt->is_inf(Math::BigInt->binf); 

__END__ 
0 
1 
1 

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