Fortran
जानकारी का प्रकार

आंतरिक प्रकार

फोरट्रान के लिए डेटा प्रकार आंतरिक हैं :

integer
real
character
complex
logical

integer , real और complex संख्यात्मक प्रकार हैं।

character एक प्रकार है जिसका उपयोग चरित्र तार को संग्रहीत करने के लिए किया जाता है।

logical का उपयोग द्विआधारी मूल्यों को संग्रहीत करने के लिए किया जाता है .true. या .false. ।

सभी संख्यात्मक और तार्किक आंतरिक प्रकार के प्रकारों का उपयोग करके पैरामीट्रिक किया जाता है।

integer(kind=specific_kind)

या केवल

integer(specific_kind)

जहाँ specific_kind एक पूर्णांक है जिसका नाम स्थिर है।

चरित्र चर, साथ ही एक प्रकार का पैरामीटर होने के साथ-साथ एक लंबाई पैरामीटर भी होता है:

character char

वाणी char डिफ़ॉल्ट तरह की लंबाई -1 चरित्र चर हो सकता है, जबकि

character(len=len) name

name को डिफ़ॉल्ट प्रकार और लंबाई len का वर्ण चर घोषित करता है। तरह भी निर्दिष्ट किया जा सकता है

character(len=len, kind=specific_kind) name
character(kind=specific_kind) char

name को एक kind और लंबाई len का चरित्र घोषित करता है। char प्रकार की लंबाई -1 चरित्र है kind ।

वैकल्पिक रूप से, चरित्र घोषणा के लिए अप्रचलित रूप

character*len  name

पुराने कोड में देखा जा सकता है, name घोषणा लंबाई len और डिफ़ॉल्ट चरित्र प्रकार की हो सकती है।

आंतरिक प्रकार के एक वैरिएबल की घोषणा ऊपर दिए गए फॉर्म की हो सकती है, लेकिन यह भी type(...) फॉर्म का उपयोग कर सकती है:

integer i
real x
double precision y

के बराबर है (लेकिन बहुत अधिक पसंदीदा)

type(integer) i
type(real) x
type(double precision) y

व्युत्पन्न डेटा प्रकार

एक नए प्रकार को परिभाषित करें, mytype :

type :: mytype
  integer :: int
  real    :: float
end type mytype

प्रकार mytype का एक वैरिएबल घोषित करें:

type(mytype) :: foo

एक व्युत्पन्न प्रकार के घटकों को % ऑपरेटर ^{1 के} साथ एक्सेस किया जा सकता है:

foo%int = 4
foo%float = 3.142

एक फोरट्रान 2003 सुविधा (अभी तक सभी संकलक द्वारा लागू नहीं की गई है) पैरामीटर डेटा प्रकारों को परिभाषित करने की अनुमति देता है:

type, public :: matrix(rows, cols, k)
  integer, len :: rows, cols
  integer, kind :: k = kind(0.0)
  real(kind = k), dimension(rows, cols) :: values
end type matrix

व्युत्पन्न प्रकार matrix में तीन प्रकार के पैरामीटर होते हैं जो टाइप नाम के बाद कोष्ठक में सूचीबद्ध होते हैं (वे rows , cols , और k )। प्रत्येक प्रकार के पैरामीटर की घोषणा में यह इंगित किया जाना चाहिए कि वे प्रकार ( kind ) या लंबाई ( len ) प्रकार के पैरामीटर हैं।

प्रकार के पैरामीटर, जैसे आंतरिक प्रकार के होते हैं, निरंतर अभिव्यक्ति होनी चाहिए जबकि लंबाई प्रकार के पैरामीटर, आंतरिक चरित्र चर की लंबाई की तरह, निष्पादन के दौरान भिन्न हो सकते हैं।

ध्यान दें कि पैरामीटर k का एक डिफ़ॉल्ट मान है, इसलिए इसे इस प्रकार प्रदान किया जा सकता है या छोड़ा जा सकता है जब प्रकार matrix का एक चर घोषित किया जाता है, जो निम्नानुसार है

type (matrix (55, 65, kind=double)) :: b, c ! default parameter provided
type (matrix (rows=40, cols=50)     :: m    ! default parameter omitted

एक व्युत्पन्न प्रकार का नाम doubleprecision या किसी भी आंतरिक प्रकार के समान नहीं हो सकता है।

1. बहुत से लोग आश्चर्य करते हैं कि फोरट्रान घटक-पहुंच ऑपरेटर के रूप में % का उपयोग क्यों करता है, बजाय अधिक सामान्य . । इसकी वजह है . ऑपरेटर सिंटैक्स द्वारा पहले ही ले लिया गया है .not. .and. , .my_own_operator. ।

फ्लोटिंग पॉइंट नंबरों की शुद्धता

real प्रकार के फ्लोटिंग पॉइंट नंबरों का कोई वास्तविक मूल्य नहीं हो सकता है। वे दशमलव अंकों की निश्चित मात्रा तक वास्तविक संख्या का प्रतिनिधित्व कर सकते हैं।

फोरट्रान 77 ने दो फ़्लोटिंग पॉइंट प्रकारों की गारंटी दी है और अधिक हाल के मानक कम से कम दो वास्तविक प्रकारों की गारंटी देते हैं। वास्तविक चर के रूप में घोषित किया जा सकता है

real x
double precision y

x यहां डिफ़ॉल्ट प्रकार का वास्तविक है और x तुलना में अधिक दशमलव परिशुद्धता के साथ y वास्तविक प्रकार का है। फोरट्रान 2008 में, y की दशमलव सटीकता कम से कम 10 है और इसकी दशमलव प्रतिपादक सीमा कम से कम 37 है।

 real, parameter             :: single = 1.12345678901234567890
 double precision, parameter :: double = 1.12345678901234567890d0
 
 print *, single
 print *, double

प्रिंट

   1.12345684    
   1.1234567890123457

डिफ़ॉल्ट कॉन्फ़िगरेशन का उपयोग करके सामान्य कंपाइलरों में।

डबल सटीक स्थिरांक में d0 को नोटिस करें। एक वास्तविक शाब्दिक जिसमें घातांक को निरूपित करने के लिए e बजाय d का उपयोग किया जाता है, डबल परिशुद्धता को इंगित करता है।

! Default single precision constant
1.23e45
! Double precision constant
1.23d45

फोरट्रान 90 ने प्रकारों का उपयोग करके real प्रकारों को परिचालित किया। वास्तविक प्रकार एक स्थिर या शाब्दिक स्थिरांक नामक पूर्णांक है:

real(kind=real_kind) :: x

या केवल

real(real_kind) :: x

यह बयान वाणी x के प्रकार के होने के लिए real एक निश्चित परिशुद्धता के मूल्य के आधार के साथ real_kind ।

फ्लोटिंग पॉइंट शाब्दिक एक प्रत्यय का उपयोग करके एक विशिष्ट प्रकार के साथ घोषित किया जा सकता है

1.23456e78_real_kind

real_kind का सटीक मान मानकीकृत नहीं है और संकलक से संकलक में भिन्न होता है। किसी भी वास्तविक चर या स्थिरांक की तरह पूछताछ करने के लिए, फ़ंक्शन kind() का उपयोग किया जा सकता है:

print *, kind(1.0), kind(1.d0)

आम तौर पर प्रिंट होगा

4 8

या

1 2

संकलक के आधार पर।

कई तरह से सेट किए जा सकते हैं:

1. एकल (डिफ़ॉल्ट) और दोहरी परिशुद्धता:

   integer, parameter :: single_kind = kind(1.)
   integer, parameter :: double_kind = kind(1.d0)
   

2. आवश्यक दशमलव सटीकता को निर्दिष्ट करने के लिए आंतरिक फ़ंक्शन चयनित_real_kind selected_real_kind([p, r]) का उपयोग करना। लौटे प्रकार में कम से कम p अंकों की शुद्धता होती है और कम से कम r घातांक की अनुमति देता है।

   integer, parameter :: single_kind = selected_real_kind( p=6, r=37 )
   integer, parameter :: double_kind = selected_real_kind( p=15, r=200 )
   

3. फोरट्रान 2003 के साथ शुरू, पूर्व-परिभाषित स्थिरांक आंतरिक मॉड्यूल ISO_C_Binding माध्यम से उपलब्ध हैं ताकि यह सुनिश्चित किया जा सके कि वास्तविक प्रकार के float साथ double या long_double प्रकार के float साथ अंतर-संचालन योग्य हैं:

   use ISO_C_Binding
   
   integer, parameter :: single_kind = c_float
   integer, parameter :: double_kind = c_double
   integer, parameter :: long_kind = c_long_double
   

4. फोरट्रान 2008 से शुरू, पूर्व-परिभाषित स्थिरांक आंतरिक मॉड्यूल ISO_Fortran_env माध्यम से उपलब्ध हैं। ये स्थिरांक बिट्स में निश्चित भंडारण आकार के साथ वास्तविक प्रकार प्रदान करते हैं

   use ISO_Fortran_env
   
   integer, parameter :: single_kind = real32
   integer, parameter :: double_kind = real64
   integer, parameter :: quadruple_kind = real128
   

यदि कंपाइलर में कुछ विशेष प्रकार उपलब्ध नहीं है, तो selected_real_kind() या पूर्णांक स्थिरांक का मान -1 ।

मान लिया गया और आस्थगित लंबाई प्रकार पैरामीटर

लंबाई प्रकार के साथ वर्ण प्रकार या व्युत्पन्न प्रकार के वेरिएबल लंबाई पैरामीटर या तो मान लिया गया या स्थगित हो सकता है । वर्ण चर name

character(len=len) name

लंबाई की है len निष्पादन के दौरान। इसके विपरीत लंबाई निर्दिष्ट या तो हो सकता है

character(len=*) ...  ! Assumed length

या

character(len=:) ...  ! Deferred length

मान लिया गया कि लंबाई चर एक अन्य इकाई से अपनी लंबाई मान लेते हैं।

समारोह में

function f(dummy_name)
  character(len=*) dummy_name
end function f

डमी तर्क dummy_name की वास्तविक तर्क की लंबाई है।

नाम निरंतर const_name में

character(len=*), parameter :: const_name = 'Name from which length is assumed'

लंबाई को दायीं ओर स्थिर अभिव्यक्ति द्वारा दिया गया है।

निष्पादन के दौरान आस्थगित लंबाई प्रकार पैरामीटर भिन्न हो सकते हैं। आस्थगित लंबाई के साथ एक चर में allocatable या pointer विशेषता होनी चाहिए

character(len=:), allocatable :: alloc_name
character(len=:), pointer :: ptr_name

इस तरह के एक चर की लंबाई निम्नलिखित तरीकों में से किसी में भी सेट की जा सकती है

allocate(character(len=5) :: alloc_name, ptr_name)
alloc_name = 'Name'         ! Using allocation on intrinsic assignment
ptr_name => another_name    ! For given target

लंबाई पैरामीटर के साथ व्युत्पन्न प्रकारों के लिए सिंटैक्स समान है

  type t(len)
    integer, len :: len
    integer i(len)
  end type t

  type(t(:)), allocatable :: t1
  type(t(5)) t2

  call sub(t2)
  allocate(type(t(5)) :: t1)

contains

  subroutine sub(t2)
    type(t(*)), intent(out) :: t2
  end subroutine sub

end  

शाब्दिक अर्थ

प्रोग्राम इकाइयाँ अक्सर शाब्दिक स्थिरांक का उपयोग करती हैं। ये जैसे स्पष्ट मामलों को कवर करते हैं

print *, "Hello", 1, 1.0

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

इंटीजर शाब्दिक स्थिरांक रूप हैं

1
-1
-1_1   ! For valid kind parameter 1
1_ik   ! For the named constant ik being a valid kind paramter

वास्तविक शाब्दिक स्थिरांक रूप हैं

1.0    ! Default real
1e0    ! Default real using exponent format
1._1   ! Real with kind parameter 1 (if valid)
1.0_sp ! Real with kind paramter named constant sp
1d0    ! Double precision real using exponent format
1e0_dp ! Real with kind named constant dp using exponent format

जटिल शाब्दिक स्थिरांक रूप हैं

(1, 1.)       ! Complex with integer and real components, literal constants
(real, imag)  ! Complex with named constants as components

यदि वास्तविक और काल्पनिक घटक दोनों पूर्णांक हैं, तो जटिल शाब्दिक स्थिरांक डिफ़ॉल्ट जटिल है, और पूर्णांक घटक डिफ़ॉल्ट वास्तविक में बदल जाते हैं। यदि एक घटक वास्तविक है, तो जटिल शाब्दिक स्थिरांक का प्रकार वास्तविक (और पूर्णांक घटक उस वास्तविक में परिवर्तित होता है) है। यदि दोनों घटक वास्तविक हैं तो जटिल शाब्दिक स्थिरांक सबसे बड़ी सटीकता के साथ वास्तविक प्रकार का है।

तार्किक शाब्दिक स्थिरांक हैं

.TRUE.     ! Default kind, with true value
.FALSE.    ! Default kind, with false value
.TRUE._1   ! Of kind 1 (if valid), with true value
.TRUE._lk  ! Of kind named constant lk (if valid), with true value

चरित्र के शाब्दिक मूल्य अवधारणा में थोड़ा भिन्न होते हैं, इस तरह के मूल्य के प्रकार निर्दिष्ट करते हैं

"Hello"       ! Character value of default kind
'Hello'       ! Character value of default kind
ck_"Hello"    ! Character value of kind ck
"'Bye"        ! Default kind character with a '
'''Bye'       ! Default kind character with a '
""            ! A zero-length character of default kind

जैसा कि ऊपर सुझाव दिया गया है, चरित्र शाब्दिक स्थिरांक को एपोस्ट्रोफ या उद्धरण चिह्नों द्वारा परिसीमित किया जाना चाहिए, और प्रारंभ और अंत मार्कर को मेल खाना चाहिए। शाब्दिक apostrophes उद्धरण चिह्न delimiters के भीतर होने से या दोगुनी दिखाई देने के द्वारा शामिल किया जा सकता है। उद्धरण चिह्नों के लिए भी यही है।

BOZ स्थिरांक ऊपर से अलग हैं, इसमें वे केवल एक मूल्य निर्दिष्ट करते हैं: उनका कोई प्रकार या प्रकार पैरामीटर नहीं है। BOZ स्थिरांक एक सा पैटर्न है और इसे इस प्रकार निर्दिष्ट किया जाता है

B'00000'    ! A binary bit pattern
B"01010001" ! A binary bit pattern
O'012517'   ! An octal bit pattern
O"1267671"  ! An octal bit pattern
Z'0A4F'     ! A hexadecimal bit pattern
Z"FFFFFF"   ! A hexadecimal bit pattern

BOZ शाब्दिक स्थिरांक सीमित हैं जहां वे प्रकट हो सकते हैं: data स्टेटमेंट में स्थिरांक और आंतरिक प्रक्रियाओं के चयन के रूप में।

चरित्रवान पदार्थों तक पहुँच

चरित्र इकाई के लिए

character(len=5), parameter :: greeting = "Hello"

एक सबरिंग को सिंटैक्स के साथ संदर्भित किया जा सकता है

greeting(2:4)  ! "ell"

एक अक्षर तक पहुँचने के लिए यह लिखना पर्याप्त नहीं है

greeting(1)    ! This isn't the letter "H"

परंतु

greeting(1:1)  ! This is "H"

एक चरित्र सरणी के लिए

character(len=5), parameter :: greeting(2) = ["Hello", "Yo!  "]

हमारे पास पहुँच की तरह है

greeting(1)(2:4)  ! "ell"

लेकिन हम गैर-सन्निहित वर्णों का संदर्भ नहीं दे सकते

greeting(:)(2:4)  ! The parent string here is an array

यहां तक कि हम शाब्दिक स्थिरांक के पदार्थों को भी एक्सेस कर सकते हैं

"Hello"(2:4)

वर्ण चर के एक हिस्से को चर के रूप में एक विकल्प का उपयोग करके भी परिभाषित किया जा सकता है। उदाहरण के लिए

integer :: i=1
character :: filename = 'file000.txt'

filename(9:11) = 'dat'
write(filename(5:7), '(I3.3)') i

जटिल घटकों तक पहुँचना

जटिल इकाई

complex, parameter :: x = (1., 4.)

वास्तविक भाग 1. और जटिल भाग 4. । हम इन व्यक्तिगत घटकों को एक्सेस कर सकते हैं

real(x)  ! The real component
aimag(x) ! The complex component
x%re     ! The real component
y%im     ! The complex component

x%.. फ़ॉर्म फोरट्रान 2008 में नया है और व्यापक रूप से संकलक में समर्थित नहीं है। हालाँकि, इस फॉर्म का उपयोग किसी जटिल चर के अलग-अलग घटकों को सीधे सेट करने के लिए किया जा सकता है

complex y
y%re = 0.
y%im = 1.

घोषणा और विशेषताएँ

यहाँ विषयों और उदाहरणों के माध्यम से हम चर, कार्यों आदि की कई घोषणाएँ देखेंगे।

उनके नाम के साथ-साथ डेटा ऑब्जेक्ट में भी विशेषताएँ हो सकती हैं। इस विषय में कवर किए गए जैसे घोषणा बयान हैं

integer, parameter :: single_kind = kind(1.)

जो वस्तु को single_kind गुण देता है parameter गुण (इसे नामांकित स्थिरांक बनाता है)।

कई अन्य विशेषताएं हैं, जैसे

• target
• pointer
• optional
• save

विशेषताओं को तथाकथित विशेषता विनिर्देश विवरणों के साथ निर्दिष्ट किया जा सकता है

integer i    ! i is an integer (of default kind)...
pointer i    ! ... with the POINTER attribute...
optional i   ! ... and the OPTIONAL attribute

हालांकि, आमतौर पर इन विशेषताओं विनिर्देश विवरणों का उपयोग करने से बचने के लिए बेहतर माना जाता है। स्पष्टता के लिए विशेषताओं को एकल घोषणा के भाग के रूप में निर्दिष्ट किया जा सकता है

integer, pointer, optional :: i

यह अंतर्निहित टाइपिंग का उपयोग करने के प्रलोभन को भी कम करता है।

फोरट्रान प्रलेखन में ज्यादातर मामलों में यह एकल घोषणा बयान पसंद किया जाता है।