फोरट्रान: आकार की हैंडलिंग पूर्णांक मूल्यों: ~ 700,000,000,000

Question

वर्तमान में मैं अपने Fortran95 ज्ञान पर का प्रयोग करने कर रहा हूँ (मत पूछो क्यों) ...

मैं हालांकि एक समस्या में चल रहा हूँ। एक बड़े पूर्णांक को कैसे संभालता है, उदाहरण के लिए। का आकार: ~ 700000000000

INTEGER (KIND = 3) इस नंबर को नहीं रख सकता है। यदि कोई दिलचस्पी है तो मेरे पास उपलब्ध संकलक Silverfrost FTN95 है।

मैं डेटा के एक बड़े सेट के माध्यम से चलाने के लिए पूर्णांक का उपयोग कर रहा हूं।

क्या आपके पास कोई सुझाव है?

Answer 1

मानक समाधान (फोरट्रान 95 के बाद से, तो मैं अपने संकलक इसका समर्थन करता है मान) मान्य पूर्णांक प्रकार (जिनके मान संकलक निर्भर कर रहे हैं) और HUGE आंतरिक के लिए जांच करने के लिए SELECTED_INT_KIND आंतरिक उपयोग करने के लिए है।

• SELECTED_INT_KIND (R) रिटर्न एक पूर्णांक प्रकार की तरह प्रकार पैरामीटर है कि सभी पूर्णांक मूल्यों का प्रतिनिधित्व करता है n के साथ -10^आर < n < 10^आर (और रिटर्न -1 ऐसी कोई प्रकार मौजूद है)।
• HUGE (K) के पूर्णांक प्रकार में सबसे बड़ा प्रदर्शनीय संख्या दिखाता तरह लालकृष्ण

उदाहरण के लिए, एक x86_64 प्रोसेसर के साथ मेरी मैक (gfortran संकलक, 64-बिट मोड), निम्नलिखित कार्यक्रम पर:

print *, selected_int_kind(1) 
    print *, selected_int_kind(4) 
    print *, selected_int_kind(8) 
    print *, selected_int_kind(16) 
    print *, selected_int_kind(32) 
    print *, selected_int_kind(64) 
    print *, huge(0_1) 
    print *, huge(0_2) 
    print *, huge(0_4) 
    print *, huge(0_8) 
    print *, huge(0_16) 
    end 

आउटपुट:

  1 
      2 
      4 
      8 
      16 
      -1 
    127 
    32767 
    2147483647 
    9223372036854775807 
170141183460469231731687303715884105727 

जो मुझसे कहता है कि मैं अपने काम के लिए एक integer(kind=8) का उपयोग करेंगे।

Answer 2

यदि आप इसे लूप कंट्रोल वैरिएबल के रूप में उपयोग कर रहे हैं, लेकिन सीधे पूर्णांक का उपयोग नहीं कर रहे हैं (जो मुझे लगता है कि आप नहीं हो सकते हैं, क्योंकि आप सबसे बड़ी अनुक्रमणिका के मुकाबले एक सरणी घोषित नहीं कर सकते हैं, है ना?), तो मुझे लगता है कि करने के लिए चीज उस पिल्ला को 100000 की तरह कुछ विभाजित करती है और अपने लूप को दूसरे लूप में घोंसला देती है जो कई बार पुनरावृत्त करती है।

Answer 3

क्या आपने INTEGER (KIND = 4) की कोशिश की है?

Answer 4

हमारा उत्तर मूल्य को एक डबल परिशुद्धता चर में रखना था और किसी भी आंशिक भागों से छुटकारा पाने के लिए उस पर एक डीआईएनटी करना था। परिणाम एक डबल सटीक चर में रखा एक पूर्णांक हैं। फ़ंक्शन डीआईएनटी हमेशा सभी फोरट्रानों के लिए उपलब्ध नहीं है। फ़ंक्शन एक डबल परिशुद्धता पूर्णांक फ़ंक्शन है और यह बहुत बड़े पूर्णांक (17 अंकों तक) की अनुमति देगा।

Answer 5

फोरट्रान के लिए कई मुफ्त arbitrary-precision पुस्तकालय उपलब्ध हैं जो इस समस्या से निपटेंगे। FMLIB एक है। पांच या छह और विकल्प linked from this page हैं।

Answer 6

पोर्टेबल एक पूर्णांक "सूचकांक" कम से कम 12 दशमलव अंक होगा कि घोषित करने के लिए है:

integer, parameter :: MyLongIntType = selected_int_kind (12) 
integer (kind=MyLongIntType) :: index 

"प्रकार =" हटाया जा सकता है।

3 जैसे विशिष्ट मानों का उपयोग पूरी तरह गैर पोर्टेबल है और अनुशंसित नहीं है।कुछ कंपाइलर लगातार प्रकार की संख्या का उपयोग करते हैं, अन्य बाइट्स की संख्या का उपयोग करते हैं। "Select_int_kind" संकलक को उपलब्ध सबसे छोटे पूर्णांक प्रकार की तरह की संख्या लौटाएगा जो अंकों की अनुरोधित संख्या का प्रतिनिधित्व कर सकता है। यदि ऐसा कोई प्रकार मौजूद नहीं है, -1 वापस कर दिया जाएगा, और जब एक पूर्णांक घोषित करने के लिए दयालु मूल्य का उपयोग किया जाता है तो मान विफल हो जाएगा।

दोनों gfortran और ifort दशमलव अंकों के इनपुट के लिए 18 तक ऊपर दशमलव_ इनपुट के लिए एक प्रकार लौटाते हैं। 18 जैसे बड़े मूल्य आमतौर पर 9 223372036854775807 के सबसे बड़े सकारात्मक मूल्य के साथ 8-बाइट पूर्णांक का चयन करेंगे। इसमें 1 9 अंक हैं, लेकिन यदि एक कंपाइलर इस प्रकार का समर्थन करता है लेकिन लंबे समय तक नहीं, select_int_kind (1 9) -1 होगा, क्योंकि सभी 1 9 अंकों के पूर्णांक प्रतिनिधित्व योग्य नहीं हैं।