Fortran
प्रक्रियाएं - कार्य और उप-प्रक्रिया

टिप्पणियों

कार्य सिंटैक्स

कई प्रकार के सिंटैक्स का उपयोग करके कार्यों को लिखा जा सकता है

function name()
  integer name
  name = 42
end function

integer function name()
  name = 42
end function

function name() result(res)
  integer res
  res = 42
end function

कार्य एक समारोह परिणाम के माध्यम से मान। जब तक फ़ंक्शन स्टेटमेंट का result खंड नहीं होता है तब तक फ़ंक्शन के परिणाम का फ़ंक्शन के समान नाम होता है। साथ result समारोह नतीजा यह है कि द्वारा दिए गए है result । फ़ंक्शन परिणाम के ऊपर पहले दो उदाहरणों में से प्रत्येक को name दिया गया है; res द्वारा तीसरे में।

फ़ंक्शन के निष्पादन के दौरान फ़ंक्शन परिणाम को परिभाषित किया जाना चाहिए।

फ़ंक्शंस कुछ विशेष उपसर्गों का उपयोग करने की अनुमति देते हैं।

शुद्ध फ़ंक्शन का अर्थ है कि इस फ़ंक्शन का कोई दुष्प्रभाव नहीं है:

pure real function square(x)
  real, intent(in) :: x
  square = x * x
end function

मौलिक समारोह अदिश ऑपरेटर के रूप में परिभाषित किया गया है लेकिन यह वास्तविक तर्क के रूप में देता है जो मामले में समारोह तत्व के लिहाज से लागू किया जाएगा के साथ लागू किया जा सकता है। जब तक impure उपसर्ग (फोरट्रान 2008 में पेश किया गया है) निर्दिष्ट किया जाता है एक मौलिक कार्य भी एक शुद्ध कार्य है।

elemental real function square(x)
  real, intent(in) :: x
  square = x * x
end function

वापसी का बयान

return स्टेटमेंट का उपयोग फ़ंक्शन और सबरूटीन से बाहर निकलने के लिए किया जा सकता है। कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, इसका उपयोग रिटर्न मान सेट करने के लिए नहीं किया जाता है।

real function f(x)
  real, intent(in) :: x
  integer :: i

  f = x

  do i = 1, 10

    f = sqrt(f) - 1.0

    if (f < 0) then
      f = -1000.
      return
    end if

  end do
end function

यह कार्य एक पुनरावृत्त संगणना करता है। यदि f का मान ऋणात्मक हो जाता है तो फ़ंक्शन -1000 मान लौटाता है।

पुनरावर्ती प्रक्रियाएं

फोरट्रान फ़ंक्शंस और सबरूटीन्स को स्पष्ट रूप से पुनरावर्ती के रूप में घोषित करने की आवश्यकता होती है, यदि वे खुद को फिर से, प्रत्यक्ष या अप्रत्यक्ष रूप से कॉल करने के लिए हों। इस प्रकार, फिबोनाची श्रृंखला का एक पुनरावर्ती कार्यान्वयन इस तरह दिख सकता है:

recursive function fibonacci(term) result(fibo)
  integer, intent(in) :: term
  integer :: fibo

  if (term <= 1) then
    fibo = 1
  else
    fibo = fibonacci(term-1) + fibonacci(term-2)
  end if
  
end function fibonacci

एक अन्य उदाहरण में तथ्य की गणना करने की अनुमति है:

recursive function factorial(n)  result(f)
  integer :: f
  integer, intent(in) :: n
  
  if(n == 0) then
    f = 1
  else
    f = n * f(n-1)
  end if
end function factorial

फ़ंक्शन को सीधे पुनरावर्ती रूप से संदर्भित करने के लिए, इसकी परिभाषा को result प्रत्यय का उपयोग करना चाहिए। एक फ़ंक्शन के लिए recursive और elemental दोनों होना संभव नहीं है।

डमी तर्क के इरादे

सबरूटीन या फ़ंक्शन में एक डमी तर्क का intent विशेषता इसका इच्छित उपयोग घोषित करता है। वाक्यविन्यास या तो एक है

intent(IN)
intent(OUT)
intent(INOUT)

उदाहरण के लिए, इस फ़ंक्शन पर विचार करें:

real function f(x)
  real, intent(IN) :: x

  f = x*x
end function

intent(IN) निर्दिष्ट करता है कि (नॉन-पॉइंटर) डमी तर्क x को कभी भी पूरे फ़ंक्शन या इसके आरंभीकरण में परिभाषित नहीं किया जा सकता है या अपरिभाषित नहीं किया जा सकता है। यदि कोई पॉइंटर डमी तर्क में विशेषता intent(IN) , तो यह उसके संघ पर लागू होता है।

नॉन-पॉइंटर डमी तर्क के लिए intent(OUT) अर्थ है कि उपप्रोग्राम के आह्वान पर डमी तर्क अपरिभाषित हो जाता है (डिफ़ॉल्ट आरंभीकरण के साथ व्युत्पन्न प्रकार के किसी भी घटक को छोड़कर) और निष्पादन के दौरान सेट किया जाना है। डमी तर्क के रूप में पारित वास्तविक तर्क निश्चित होना चाहिए: एक नामित या शाब्दिक निरंतर या एक अभिव्यक्ति को पारित करने की अनुमति नहीं है।

पहले की तरह, यदि एक पॉइंटर डमी तर्क intent(OUT) है, तो पॉइंटर की एसोसिएशन स्थिति अपरिभाषित हो जाती है। यहां वास्तविक तर्क एक सूचक चर होना चाहिए।

intent(INOUT) निर्दिष्ट करता है कि वास्तविक तर्क निश्चित है और प्रक्रिया से डेटा को वापस करने और वापस भेजने दोनों के लिए उपयुक्त है।

अंत में, एक डमी तर्क intent विशेषता के बिना हो सकता है। इस तरह के एक डमी तर्क का उपयोग वास्तविक तर्क द्वारा पारित सीमित है।

उदाहरण के लिए, विचार करें

integer :: i = 0
call sub(i, .TRUE.)
call sub(1, .FALSE.)

end

subroutine sub(i, update)
  integer i
  logical, intent(in) :: update
  if (update) i = i+1
end subroutine

i तर्क में कोई intent विशेषता नहीं हो सकती है जो मुख्य कार्यक्रम के सबरूटीन कॉल की अनुमति देता है।

एक प्रक्रिया का संदर्भ लेना

किसी फ़ंक्शन या सबरूटीन के लिए उपयोगी होने के लिए इसे संदर्भित करना होगा। एक उप-कथन एक call स्टेटमेंट में संदर्भित किया जाता है

call sub(...)

और एक अभिव्यक्ति के भीतर एक समारोह। कई अन्य भाषाओं के विपरीत, एक अभिव्यक्ति पूर्ण बयान नहीं बनाती है, इसलिए एक फ़ंक्शन संदर्भ अक्सर एक असाइनमेंट स्टेटमेंट में देखा जाता है या किसी तरह से उपयोग किया जाता है:

x = func(...)
y = 1 + 2*func(...)

संदर्भित करने के लिए एक प्रक्रिया को नामित करने के तीन तरीके हैं:

• एक प्रक्रिया या प्रक्रिया सूचक के नाम के रूप में
• एक व्युत्पन्न प्रकार की वस्तु का एक प्रक्रिया घटक
• एक प्रकार की बाध्य प्रक्रिया बाध्यकारी नाम

पहले के रूप में देखा जा सकता है

procedure(), pointer :: sub_ptr=>sub
call sub()   ! With no argument list the parentheses are optional
call sub_ptr()
end

subroutine sub()
end subroutine

और अंतिम दो के रूप में

module mod
  type t
    procedure(sub), pointer, nopass :: sub_ptr=>sub
  contains
    procedure, nopass :: sub
  end type

contains

  subroutine sub()
  end subroutine

end module

use mod
type(t) x
call x%sub_ptr()   ! Procedure component
call x%sub()       ! Binding name

end

डमी तर्कों के साथ एक प्रक्रिया के लिए संदर्भ को वास्तविक तर्कों की आवश्यकता होती है, हालांकि वैकल्पिक डमी तर्क नहीं दिए जा सकते हैं।

सबरूटीन पर विचार करें

subroutine sub(a, b, c)
  integer a, b
  integer, optional :: c
end subroutine

इसे निम्नलिखित दो तरीकों से संदर्भित किया जा सकता है

call sub(1, 2, 3)   ! Passing to the optional dummy c
call sub(1, 2)      ! Not passing to the optional dummy c

यह तथाकथित स्थिति संदर्भित है: तर्क सूची में स्थिति के आधार पर वास्तविक तर्क जुड़े हुए हैं। इधर, डमी a साथ जुड़ा हुआ है 1 , b के साथ 2 और c (निर्दिष्ट) के साथ 3 ।

वैकल्पिक रूप से, कीवर्ड संदर्भ का उपयोग तब किया जा सकता है जब प्रक्रिया में एक स्पष्ट इंटरफ़ेस उपलब्ध हो

call sub(a=1, b=2, c=3)
call sub(a=1, b=2)

जो ऊपर के समान है।

हालांकि, कीवर्ड के साथ वास्तविक तर्क किसी भी क्रम में पेश किए जा सकते हैं

call sub(b=2, c=3, a=1)
call sub(b=2, a=1)

स्थिति और खोजशब्द संदर्भ दोनों का उपयोग किया जा सकता है

call sub(1, c=3, b=2)

जब तक किसी कीवर्ड की पहली उपस्थिति के बाद प्रत्येक तर्क के लिए एक कीवर्ड दिया जाता है

call sub(b=2, 1, 3)  ! Not valid: all keywords must be specified

कीवर्ड रेफ़रिंग का मूल्य विशेष रूप से तब स्पष्ट किया जाता है जब कई वैकल्पिक डमी तर्क होते हैं, जैसा कि नीचे देखा गया है यदि b से ऊपर सबरूटीन परिभाषा में भी वैकल्पिक थे

call sub(1, c=3)  ! Optional b is not passed

तर्क-प्रकार की प्रक्रियाओं या घटक प्रक्रिया बिंदुओं के लिए पारित तर्क के साथ सूचियों को अलग से माना जाता है।