फोरट्रान: सबसे बड़ा और सबसे छोटा पूर्णांक

Question

फोरट्रान पूरी तरह से मेरे लिए नया है, किसी को भी मुझे follwing समस्या को हल करने में मदद कर सकते हैं? मैं अपने पीसी पर सभी प्रकार की संख्या के लिए सभी पूर्णांक प्रकारों और सबसे बड़े और सबसे छोटे मूल्य को जानना चाहता हूं। मेरे पास नीचे सूचीबद्ध कोड है:

program intkind 
implicit none 

integer :: n=1 
integer :: integer_range =1 


do while(integer_range /= -1) 
    print*, "kind_number ", selected_int_kind(n) 
    call rang(integer_range) 
    n = n *2 
    integer_range = selected_int_kind(n) 
end do 

contains 
subroutine rang(largest) 
    integer largest 
    print*, huge(largest) 

end subroutine 

end 

पूर्णांक प्रकार जो मुझे मिलते हैं वे हैं: 1,2,4,8। 2147483647:

1. प्रत्येक प्रकार संख्या उसी के लिए प्रत्येक सबसे बड़ा पूर्णांक क्यों है? और क्या सबसे छोटा पूर्णांक के लिए एक आंतरिक कार्य है?

2. जब मैं subroutine rang कहलाता हूं तो मैं पूर्णांक प्रकार को कैसे रख सकता हूं? मुझे लगता है कि यह सबसे बड़ा पूर्णांक की कुंजी है।

Answer 1

आपका सबरूटीन:

subroutine rang(largest) 
    integer :: largest 
    print *, huge(largest) 
end subroutine 

इनपुट के रूप में एक डिफ़ॉल्ट आकार पूर्णांक लेता है, और सबसे बड़ी संभव मूल्य कि कि डिफ़ॉल्ट आकार पूर्णांक में फिट होगा प्रिंट करता है। यह होगा हमेशा वापसी विशाल (डिफ़ॉल्ट पूर्णांक) जो है, सबसे सिस्टम पर, विशाल (4 बाइट-पूर्णांक), या 2147483647 huge केवल वैरिएबल प्रकार मानता है; यह व्याख्या नहीं है किसी भी तरह से चर। एकमात्र तरीका जो आप ऊपर करने की कोशिश कर रहे हैं, वह पैरामीटरकृत व्युत्पन्न प्रकारों के साथ है, जो कि नए हैं जो कि कंपाइलर्स में इसके लिए समर्थन अभी भी थोड़ा सा स्पॉटी है।

program integerkinds 
    use iso_fortran_env 
    implicit none 

    integer :: i 
    integer(kind=int8) :: i8 
    integer(kind=int16) :: i16 
    integer(kind=int32) :: i32 
    integer(kind=int64) :: i64 

    integer(kind=selected_int_kind(6)) :: j6 
    integer(kind=selected_int_kind(15)):: j15 

    print *,'Default:' 
    print *, huge(i) 
    print *,'Int8:' 
    print *, huge(i8) 
    print *,'Int16:' 
    print *, huge(i16) 
    print *,'Int32:' 
    print *, huge(i32) 
    print *,'Int64:' 
    print *, huge(i64) 

    print *,'' 

    print *,'Selected Integer Kind 6:' 
    print *, huge(j6) 

    print *,'Selected Integer Kind 15:' 
    print *, huge(j15) 

end program integerkinds 

रनिंग देता है::

आप पूर्णांक के विभिन्न प्रकार की सीमाओं पर एक नज़र ले जाना चाहते हैं, तो आप अलग अलग चर का उपयोग करना होगा

$ ./intkinds 
Default: 
    2147483647 
Int8: 
    127 
Int16: 
    32767 
Int32: 
    2147483647 
Int64: 
    9223372036854775807 

Selected Integer Kind 6: 
    2147483647 
Selected Integer Kind 15: 
    9223372036854775807 

Answer 2

विशुद्ध रूप से एक परिशिष्ट के रूप में

, या वैकल्पिक परिप्रेक्ष्य, फोरट्रान चर को var को आवंटित स्मृति के बाइट्स की संख्या के संदर्भ में परिभाषित किया जाता है। दरअसल, सभी तुलनीय compilers, आवंटित बाइट्स के मामले में वार्स परिभाषित अन्यथा यह काफी मुश्किल होगा सिस्टम स्मृति में/दुकान आवंटित करने के लिए है, और बहुत बहुत मुश्किल इस तरह के बिना गणित आदि प्रदर्शन करने के लिए।

कुछ के लिए, मेरी तरह, यह आसान है क्या एक थोड़ा पुराने संकेतन (का इस्तेमाल करके उनकी "तरह konfusion" की तुलना में से चल रहा है देखने के लिए विशेष रूप से, बहुत सारे compilers एक सीधा 1 प्रदान करते हैं:। प्रकार और 1 के बीच पत्राचार बाइट्स/var, जो तब सबसे बड़े/छोटे इंटीजर की काफी सरलता (कुछ कंपाइलर गैर-रैखिक या गैर-प्रत्यक्ष पत्राचार का उपयोग करते हैं) की गणना करता है। हालांकि अंत में पोर्टेबिलिटी सहायता का ध्यान रखना सुनिश्चित करें। उदाहरण के लिए

Integer(1)  :: Int1  ! corresponds to a 1 byte integer 
Integer(2)  :: Int1  ! corresponds to a 2 byte integer 
Integer(4)  :: Int1  ! corresponds to a 4 byte integer 
Integer(8)  :: Int1  ! corresponds to an 8 byte integer 

इसी प्रकार के अंकन अन्य फोरट्रान प्रकार (रियल, तार्किक, आदि) पर लागू होता है। सभी वर प्रकार यदि "आकार" निर्दिष्ट नहीं है आवंटित बाइट्स की एक डिफ़ॉल्ट संख्या है।

एक विशेष प्रकार के लिए बाइट्स की अधिकतम संख्या भी संकलक और सिस्टम पर निर्भर करता है (उदाहरण के लिए इंटीजर (16) सभी प्रणालियों, आदि पर उपलब्ध नहीं है)।

एक बाइट 8 बिट्स है, इसलिए 0 से शुरू होने पर एक एकल बाइट 2^8 = 256 के सबसे बड़े मान को समायोजित करने में सक्षम होना चाहिए, या = 255।

हालांकि, फोरट्रान में, (लगभग सभी) संख्यात्मक वर्ण "हस्ताक्षरित" हैं। इसका अर्थ यह है कि थोड़ा सा प्रतिनिधित्व में कहीं एक बिट को ट्रैक करने की आवश्यकता है कि संख्या एक संख्या या एक संख्या है या नहीं। तो इस उदाहरण में, अधिकतम 2^7 होगा, क्योंकि एक बिट "साइन" जानकारी के लिए "खो गया/आरक्षित" है। इस प्रकार, हस्ताक्षरित 1-बाइट पूर्णांक के लिए संभव मान हैं -127: +128 (एब्स (सीमाएं) को 255 तक मान दें, क्योंकि कुल मिलाकर 256 "चीजें" के लिए "0" एक स्थान लेता है, क्योंकि इसे हो)।

एक समान नियम सभी ऐसे वर्रों के लिए लागू होता है, केवल एक्सोनेंट "एन" के साथ, 2^एन में, बाइट्स की संख्या के आधार पर भिन्न होता है। उदाहरण के लिए, एक इंटीजर (8) var में 8 बाइट्स, या 64 बिट्स हैं, जो 1 बिट खो गए/साइन जानकारी के लिए आरक्षित हैं, इसलिए सबसे बड़ा संभव मूल्य 2^63 = 9 223372036854775808 होगा, यदि 1 से शुरू हो रहा है, या = 4611686018427387904 प्रारंभ करते समय 0.

से मानक पूर्णांक डेटा मॉडल सामान्यीकृत किया जाएगा के रूप में:

IntNum = s * Sum[ w(k) * 2^(k-1), k=1:(NumBytes*8)-1], 

रों = "संकेत" (+/- 1), डब्ल्यू (के) या तो 1 या 0 kth बिट के लिए जहां है मूल्य।

किसी को प्रकार की घोषणाओं में स्पष्ट संख्या या env vars का उपयोग करने की आवश्यकता नहीं है; उपयोगकर्ता परिभाषित संकलन समय स्थिरांक (यानी पैरामीटर) की अनुमति है। उदाहरण

Integer, Parameter  :: DP = Kind(1.0d0) ! a standard Double Precision/8-byte declaration 
Integer, Parameter  :: I4B = 4    ! NOTICE, here the "Integer" bit has not been explicitly "sized", so defaults to "Integer(4)" 
! 
Real(DP)     :: ADoublePrecReal  ! an 8-byte Real (approx 15 decimal places with exp +/- approx 300, see Real data model) 
! 
Integer(I4B)    :: AStandardInt  ! a 4-byte integer. 

के बाद से पैरामीटर बयान एक और मॉड्यूल का उपयोग आदि के माध्यम से सुलभ में हो सकता है के लिए, यह "सटीक" वांछित के वैकल्पिक परिभाषा के लिए बड़ी जटिल कोड पुन: संयोजित करने के लिए एक सरल बात है। उदाहरण के लिए, यदि डीपी को किंड (1.0) में संपादित किया गया है, तो हर जगह घोषणा लागू होने पर "एकल परिशुद्धता" वास्तविक हो जाएगी।

फोरट्रान आंतरिक कार्यों विशाल(), छोटे() आदि यह निर्धारित करने में सहायता करते हैं कि किसी दिए गए सिस्टम पर क्या संभव है।

फोरट्रान "बिट" इंट्रिनिक्स, और अन्य टूल्स/विधियों के साथ अधिक से अधिक किया जा सकता है।