Fortran
Arrays

मूल संकेतन

किसी भी प्रकार को आयाम विशेषता का उपयोग करके एक सरणी के रूप में घोषित किया जा सकता है या केवल सरणी के सीधे dimension (ओं) को इंगित करके:

! One dimensional array with 4 elements
integer, dimension(4) :: foo

! Two dimensional array with 4 rows and 2 columns
real, dimension(4, 2) :: bar

! Three dimensional array
type(mytype), dimension(6, 7, 8) :: myarray

! Same as above without using the dimension keyword
integer :: foo2(4)
real :: bar2(4, 2)
type(mytype) :: myarray2(6, 7, 8)

बहुआयामी सरणी घोषित करने का उत्तरार्द्ध, एक ही प्रकार के विभिन्न-रैंक / आयाम सरणियों को एक में घोषित करने की अनुमति देता है, इस प्रकार है:

real :: pencil(5), plate(3,-2:4), cuboid(0:3,-10:5,6)

फोरट्रान 2008 मानक में अधिकतम रैंक (आयामों की संख्या) 15 है और पहले 7 थी।

फोरट्रान स्टोरों को स्तंभ-प्रमुख क्रम में संग्रहीत करता है। यही है, bar के तत्वों को मेमोरी में संग्रहीत किया जाता है:

bar(1, 1), bar(2, 1), bar(3, 1), bar(4, 1), bar(1, 2), bar(2, 2), ...

फोरट्रान में, सी के विपरीत सरणी क्रमांक 1 से शुरू होता है, सी के विपरीत जो 0 से शुरू होता है। वास्तव में, फोरट्रान में, आप प्रत्येक आयाम के लिए ऊपरी और निचले सीमा को स्पष्ट रूप से निर्दिष्ट कर सकते हैं:

integer, dimension(7:12, -3:-1) :: geese

यह आकार की एक सरणी (6, 3) की घोषणा करता है, जिसका पहला तत्व geese(7, -3) ।

2 (या अधिक) आयामों के साथ निचले और ऊपरी सीमा को आंतरिक कार्यों ubound और lbound द्वारा पहुँचा जा सकता है। वास्तव में lbound(geese,2) -3 वापस आएगा, जबकि ubound(geese,1) 12 वापस आएगा।

किसी सरणी का size आंतरिक फ़ंक्शन size द्वारा पहुँचा जा सकता है। उदाहरण के लिए, size(geese, dim = 1) पहले आयाम का आकार देता है जो 6 है।

सर्वव्यापी सरणियाँ

आबंटन में आवंटन विशेषता हो सकती है:

! One dimensional allocatable array
integer, dimension(:), allocatable :: foo
! Two dimensional allocatable array
real, dimension(:,:), allocatable :: bar

यह परिवर्तनशील घोषित करता है लेकिन इसके लिए कोई स्थान आवंटित नहीं करता है।

! We can specify the bounds as usual
allocate(foo(3:5))

! It is an error to allocate an array twice
! so check it has not been allocated first
if (.not. allocated(foo)) then
  allocate(bar(10, 2))
end if

एक बार एक चर की जरूरत नहीं है, यह निपटाया जा सकता है :

deallocate(foo)

यदि किसी कारण से एक allocate स्टेटमेंट विफल हो जाता है, तो प्रोग्राम बंद हो जाएगा। stat कीवर्ड के जरिए स्टेटस चेक करने पर इसे रोका जा सकता है:

real, dimension(:), allocatable :: geese
integer :: status

allocate(geese(17), stat=status)
if (stat /= 0) then
  print*, "Something went wrong trying to allocate 'geese'"
  stop 1
end if

deallocate स्टेटमेंट में stat कीवर्ड भी है:

deallocate (geese, stat=status)

status एक पूर्णांक चर है जिसका मान 0 है यदि आवंटन या डीलक्लेशन सफल था।

निर्माण करने वालों को गिरफ्तार करें

वाक्य रचना के साथ एक सरणी कंस्ट्रक्टर का उपयोग करके रैंक -1 सरणी मान बनाया जा सकता है

(/ ... /)
[ ... ]

फ़ॉर्म [...] को फोरट्रान 2003 में पेश किया गया था और आमतौर पर इसे पढ़ने के लिए स्पष्ट माना जाता है, विशेष रूप से जटिल अभिव्यक्तियों में। इस फॉर्म का उपयोग इस उदाहरण में विशेष रूप से किया जाता है।

किसी सरणी निर्माता में विशेषता मान स्केलर मान, सरणी मान या निहित-लूप हो सकते हैं।

निर्मित सरणी के प्रकार और प्रकार के पैरामीटर, सरणी निर्माणकर्ता के मानों से मेल खाते हैं

[1, 2, 3]      ! A rank-1 length-3 array of default integer type
[1., 2., 3.]   ! A rank-1 length-3 array of default real type
["A", "B"]     ! A rank-1 length-2 array of default character type

integer, parameter :: A = [2, 4]
[1, A, 3]      ! A rank-1 length-4 array of default integer type, with A's elements

integer i
[1, (i, i=2, 5), 6]  ! A rank-1 length-6 array of default integer type with an implied-do

उपरोक्त रूपों में, दिए गए सभी मान एक ही प्रकार और प्रकार के पैरामीटर के होने चाहिए। प्रकार, या प्रकार के मापदंडों को मिलाने की अनुमति नहीं है। निम्नलिखित उदाहरण मान्य नहीं हैं

[1, 2.]      ! INVALID: Mixing integer and default real
[1e0, 2d0]   ! INVALID: Mixing default real and double precision
[1., 2._dp]  ! INVALID: Allowed only if kind `dp` corresponds to default real
["Hello", "Frederick"]  ! INVALID: Different length parameters

विभिन्न प्रकारों का उपयोग करके एक सरणी का निर्माण करने के लिए, सरणी के लिए एक प्रकार का विनिर्देश दिया जाएगा

[integer :: 1, 2., 3d0]    ! A default integer array
[real(dp) :: 1, 2, 3._sp]  ! A real(dp) array
[character(len=9) :: "Hello", "Frederick"]  ! A length-2 array of length-9 characters

चरित्र सरणियों के लिए यह बाद का रूप विशेष रूप से अंतरिक्ष पैडिंग से बचने के लिए सुविधाजनक है, जैसे कि विकल्प

["Hello    ", "Frederick"]  ! A length-2 array of length-9 characters

एक सरणी के आकार को स्थिर नाम दिया जा सकता है जो इसके मूल्य को सेट करने के लिए उपयोग किए गए सरणी कंस्ट्रक्टर द्वारा निहित है

integer, parameter :: ids(*) = [1, 2, 3, 4]

और लंबाई-पैरामीटर प्रकारों के लिए लंबाई पैरामीटर मान लिया जा सकता है

character(len=*), parameter :: names(*) = [character(3) :: "Me", "You", "Her"]

शून्य-लंबाई सरणियों के निर्माण में प्रकार विनिर्देश भी आवश्यक है। से

[ ] ! Not a valid array constructor

प्रकार और प्रकार के मापदंडों को गैर-मौजूदा मूल्य सेट से निर्धारित नहीं किया जा सकता है। शून्य-लंबाई डिफ़ॉल्ट पूर्णांक सरणी बनाने के लिए:

[integer :: ]

सरणी निर्माणकर्ता केवल रैंक -1 सरणियों का निर्माण करते हैं। कई बार, जैसे नामांकित स्थिरांक का मान सेट करने में, उच्च रैंक सरणियों को भी एक अभिव्यक्ति में आवश्यक होता है। निर्मित रैंक -1 सरणी के साथ उच्च श्रेणी के सरणियों को reshape के परिणाम से लिया जा सकता है

integer, parameter :: multi_rank_ids(2,2) = RESHAPE([1,2,3,4], shape=[2,2])

एक एरे कंस्ट्रक्टर में वैल्यू लिस्ट में किसी भी एरे के साथ एलीमेंट ऑर्डर में ऐरे के मानों को रखा जाता है, हालांकि ऐरे एलिमेंट को ऐरे एलिमेंट ऑर्डर में खुद दिया जाता है। इस प्रकार, पहले का उदाहरण

integer, parameter :: A = [2, 4]
[1, A, 3]      ! A rank-1 length-4 array of default integer type, with A's elements

के बराबर है

[1, 2, 4, 3]   ! With the array written out in array element order

आमतौर पर कंस्ट्रक्टर में मान नेस्टेड सरणी कंस्ट्रक्टर सहित मनमाने ढंग से हो सकते हैं। ऐसे ऐर कंस्ट्रक्टर के लिए कुछ शर्तों को पूरा करना, जैसे कि एक स्थिर या विनिर्देश अभिव्यक्ति, घटक मूल्यों पर प्रतिबंध लागू होते हैं।

हालांकि एक सरणी कंस्ट्रक्टर नहीं, कुछ सरणी मान भी आसानी से spread आंतरिक फ़ंक्शन का उपयोग करके बनाया जा सकता है। उदाहरण के लिए

[(0, i=1,10)]  ! An array with 10 default integers each of value 0

फ़ंक्शन संदर्भ का परिणाम भी है

SPREAD(0, 1, 10)

सरणी प्रकृति विनिर्देशन: रैंक और आकार

किसी ऑब्जेक्ट पर dimension विशेषता निर्दिष्ट करती है कि ऑब्जेक्ट एक सरणी है। फ़ोर्ट्रान 2008 में, पांच सरणी के नामकरण हैं: ¹

• स्पष्ट आकार
• आकार ग्रहण किया
• आकार ग्रहण किया
• आस्थगित आकार
• निहित आकार

तीन रैंक -1 सरणियों ^{2 को लें}

integer a, b, c
dimension(5) a    ! Explicit shape (default lower bound 1), extent 5
dimension(:) b    ! Assumed or deferred shape
dimension(*) c    ! Assumed size or implied shape array

इनके साथ यह देखा जा सकता है कि किसी सरणी की प्रकृति को पूरी तरह से निर्धारित करने के लिए आगे के संदर्भ की आवश्यकता है।

स्पष्ट आकार

एक स्पष्ट आकार सरणी हमेशा अपनी घोषणा का आकार होता है। जब तक सरणी को उपप्रोग्राम या block निर्माण के लिए स्थानीय घोषित नहीं किया जाता है, आकार को परिभाषित करने वाली सीमाएं निरंतर अभिव्यक्ति होनी चाहिए। अन्य मामलों में, एक स्पष्ट आकार की सरणी एक स्वचालित वस्तु हो सकती है, जो कि एक उपप्रोग्राम या block प्रत्येक आह्वान पर भिन्न हो सकती है।

subroutine sub(n)
  integer, intent(in) :: n
  integer a(5)   ! A local explicit shape array with constant bound
  integer b(n)   ! A local explicit shape array, automatic object
end subroutine

मान लिया आकार

allocatable या pointer विशेषता के बिना एक allocatable आकृति सरणी एक डमी तर्क है। इस तरह की एक सरणी वास्तविक तर्क से अपना आकार लेती है जिसके साथ यह जुड़ा हुआ है।

integer a(5), b(10)
call sub(a)   ! In this call the dummy argument is like x(5)
call sub(b)   ! In this call the dummy argument is like x(10)

contains

  subroutine sub(x)
    integer x(:)    ! Assumed shape dummy argument
  end subroutine sub

end

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

मान लिया गया आकार

एक ग्रहण आकार सरणी एक डमी तर्क है जिसका आकार इसके वास्तविक तर्क से माना जाता है।

subroutine sub(x)
  integer x(*)   ! Assumed size array
end subroutine

मान लिया गया आकार सरणियाँ ग्रहण आकार सरणियों से बहुत अलग तरीके से व्यवहार करती हैं और ये अंतर कहीं और प्रलेखित हैं।

आस्थगित आकार

आस्थगित आकृति सरणी एक ऐसा सरणी है जिसमें allocatable या pointer विशेषता होती है। इस तरह के एक सरणी का आकार इसके आवंटन या पॉइंटर असाइनमेंट द्वारा निर्धारित किया जाता है।

integer, allocatable :: a(:)
integer, pointer :: b(:)

लगाया हुआ आकार

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

integer, parameter :: a(*) = [1,2,3,4]

डमी तर्कों पर इन सरणी घोषणाओं के निहितार्थ कहीं और प्रलेखित किए जाने हैं।

¹ फोरट्रान 2008 का विस्तार करने वाला एक तकनीकी विनिर्देश एक छठी सरणी प्रकृति जोड़ता है: मान लिया गया रैंक। यह यहां नहीं है।

² ये समान रूप से लिखे जा सकते हैं

integer, dimension(5) :: a
integer, dimension(:) :: b
integer, dimension(*) :: c

या

integer a(5)
integer b(:)
integer c(*)

संपूर्ण सरणियाँ, सरणी तत्व और सरणी अनुभाग

घोषित सरणी पर विचार करें

real x(10)

फिर हमारे पास ब्याज के तीन पहलू हैं:

1. पूरे सरणी x ;
2. सरणी तत्व, जैसे x(1) ;
3. सरणी खंड, जैसे x(2:6) ।

संपूर्ण सरणियाँ

ज्यादातर मामलों में पूरे सरणी x एक इकाई के रूप में सरणी के सभी तत्वों को संदर्भित करता है। यह print *, SUM(x) , print *, SIZE(x) या x=1 जैसे निष्पादन योग्य कथनों में दिखाई दे सकता है।

एक संपूर्ण सरणी संदर्भ सरणियों को स्पष्ट रूप से आकार नहीं दे सकती है (जैसे कि ऊपर x ):

function f(y)
  real, intent(out) :: y(:)
  real, allocatable :: z(:)

  y = 1.         ! Intrinsic assignment for the whole array
  z = [1., 2.,]  ! Intrinsic assignment for the whole array, invoking allocation
end function

एक अनुमानित आकार का सरणी पूरे सरणी के रूप में भी दिखाई दे सकता है, लेकिन केवल सीमित परिस्थितियों में (कहीं और प्रलेखित होने के लिए)।

तत्वों को सरणी

एक सरणी तत्व को पूर्णांक अनुक्रमणिका देने के लिए कहा जाता है, जो सरणी के प्रत्येक रैंक के लिए होता है, जो पूरे सरणी में स्थान को दर्शाता है:

real x(5,2)
x(1,1) = 0.2
x(2,4) = 0.3

एक सरणी तत्व एक अदिश राशि है।

सरणी अनुभाग

एक सरणी अनुभाग एक पूरे सरणी के कई तत्वों (शायद सिर्फ एक) का एक संदर्भ है, जिसमें एक सिंटैक्स शामिल है जिसमें कॉलोन शामिल हैं:

real x(5,2)
x(:,1) = 0.         ! Referring to x(1,1), x(2,1), x(3,1), x(4,1) and x(5,1)
x(2,:) = 0.         ! Referring to x(2,1), x(2,2)
x(2:4,1) = 0.       ! Referring to x(2,1), x(3,1) and x(4,1)
x(2:3,1:2) = 0.     ! Referring to x(2,1), x(3,1), x(2,2) and x(3,2)
x(1:1,1) = 0.       ! Referring to x(1,1)
x([1,3,5],2) = 0.   ! Referring to x(1,2), x(3,2) and x(5,2)

ऊपर अंतिम रूप एक वेक्टर सबस्क्रिप्ट का उपयोग करता है। यह अन्य सरणी अनुभागों से परे कई प्रतिबंधों के अधीन है।

प्रत्येक ऐरे सेक्शन अपने आप में एक एरे है, तब भी जब सिर्फ एक तत्व को संदर्भित किया जाता है। यह x(1:1,1) रैंक 1 का एक सरणी है और x(1:1,1:1) रैंक 2 का एक सरणी है।

सरणी खंडों में सामान्य रूप से पूरे सरणी की विशेषता नहीं होती है। विशेष रूप से, जहां

real, allocatable :: x(:)
x = [1,2,3]     ! x is allocated as part of the assignment
x = [1,2,3,4]   ! x is dealloacted then allocated to a new shape in the assignment

काम

x(:) = [1,2,3,4,5]   ! This is bad when x isn't the same shape as the right-hand side

अनुमति नहीं है: x(:) , हालांकि x सभी तत्वों के साथ एक सरणी अनुभाग, एक आवंटन योग्य सरणी नहीं है।

x(:) = [5,6,7,8]

ठीक है जब x दाईं ओर के आकार का है।

सरणियों के सरणी घटकों

type t
   real y(5)
end type t

type(t) x(2)

हम संपूर्ण सरणियों, सरणी तत्वों और सरणी अनुभागों को अधिक जटिल सेटिंग्स में भी संदर्भित कर सकते हैं।

ऊपर से, x एक संपूर्ण सरणी है। हमारे पास भी है

x(1)%y        ! A whole array
x(1)%y(1)     ! An array element
x%y(1)        ! An array section
x(1)%y(:)     ! An array section
x([1,2]%y(1)  ! An array section
x(1)%y(1:1)   ! An array section

ऐसे मामलों में हमें रैंक 1 की एक सरणी से संबंधित संदर्भ के एक से अधिक हिस्से की अनुमति नहीं है। निम्नलिखित, उदाहरण के लिए, अनुमति नहीं है

x%y             ! Both the x and y parts are arrays
x(1:1)%y(1:1)   ! Recall that each part is still an array section

संचालन संचालित करें

अपने कम्प्यूटेशनल लक्ष्यों के कारण, सरणियों पर गणितीय कार्य सीधे फोरट्रान में आगे हैं।

जोड़ और घटाव

एक ही आकार और आकार के सरणियों पर संचालन मैट्रिक्स बीजगणित के समान है। छोरों के साथ सभी सूचकांकों के माध्यम से चलने के बजाय, कोई जोड़ (और घटाव) लिख सकता है:

real, dimension(2,3) :: A, B, C
real, dimension(5,6,3) :: D
A    = 3.    ! Assigning single value to the whole array
B    = 5.    ! Equivalent writing for assignment
C    = A + B ! All elements of C now have value 8.
D    = A + B ! Compiler will raise an error. The shapes and dimensions are not the same

टुकड़ा करने की क्रिया से मान्य हैं:

integer :: i, j
real, dimension(3,2) :: Mat = 0.
real, dimension(3)   :: Vec1 = 0., Vec2 = 0., Vec3 = 0.
i = 0
j = 0
do i = 1,3
  do j = 1,2
    Mat(i,j) = i+j
  enddo
enddo
Vec1 = Mat(:,1)
Vec2 = Mat(:,2)
Vec3 = Mat(1:2,1) + Mat(2:3,2)

समारोह

उसी तरह, अधिकांश आंतरिक कार्यों का उपयोग घटक-वार ऑपरेशन को मानते हुए किया जा सकता है (हालांकि यह व्यवस्थित नहीं है):

real, dimension(2) :: A, B
A(1) = 6
A(2) = 44 ! Random values
B    = sin(A) ! Identical to B(1) = sin(6), B(2) = sin(44).

गुणन और भाग

उत्पाद और विभाजन के साथ सावधानी बरतनी चाहिए: * और / प्रतीकों का उपयोग करने वाले आंतरिक संचालन तत्व-वार हैं:

real, dimension(2) :: A, B, C
A(1) = 2
A(2) = 4
B(1) = 1
B(2) = 3
C = A*B ! Returns C(1) = 2*1 and C(2) = 4*3

इसे मैट्रिक्स ऑपरेशन (नीचे देखें) के साथ गलत नहीं होना चाहिए।

मैट्रिक्स ऑपरेशन

मैट्रिक्स ऑपरेशन आंतरिक प्रक्रियाएं हैं। उदाहरण के लिए, पिछले अनुभाग के सरणियों का मैट्रिक्स उत्पाद निम्नानुसार लिखा गया है:

real, dimension(2,1) :: A, B
real, dimension(1,1) :: C
A(1) = 2
A(2) = 4
B(1) = 1
B(2) = 3
C = matmul(transpose(A),B) ! Returns the scalar product of vectors A and B

जटिल ऑपरेशन अस्थायी सरणियों का निर्माण करके कार्यों के समझाया जाता है। जबकि कुछ संकलक और संकलन विकल्पों द्वारा अनुमति दी जाती है, यह अनुशंसित नहीं है। उदाहरण के लिए, मैट्रिक्स ट्रांसपोज़ सहित एक उत्पाद लिखा जा सकता है:

real, dimension(3,3) :: A, B, C
A(:) = 4
B(:) = 5
C = matmul(transpose(A),matmul(B,matmul(A,transpose(B)))) ! Equivalent to A^t.B.A.B^T

उन्नत सरणी अनुभाग: सबस्क्रिप्ट ट्रिपल और वेक्टर सदस्यताएँ

जैसा कि एक अन्य उदाहरण में उल्लेख किया गया है, सरणी के तत्वों का एक सबसेट, जिसे एक सरणी अनुभाग कहा जाता है, संदर्भित किया जा सकता है। उस उदाहरण से हमारे पास हो सकता है

real x(10)
x(:)   = 0.
x(2:6) = 1.
x(3:4) = [3., 5.]

ऐरे खंड इससे अधिक सामान्य हो सकते हैं, हालाँकि। वे सबस्क्रिप्ट ट्रिपल या वेक्टर सदस्यता का रूप ले सकते हैं।

सब्स्क्राइब्ड ट्रिपल

एक सबस्क्रिप्ट ट्रिपल रूप लेता है [bound1]:[bound2][:stride] । उदाहरण के लिए

real x(10)
x(1:10) = ...   ! Elements x(1), x(2), ..., x(10)
x(1:) = ...     ! The omitted second bound is equivalent to the upper, same as above
x(:10) = ...    ! The omitted first bound is equivalent to the lower, same as above
x(1:6:2) = ...  ! Elements x(1), x(3), x(5)
x(5:1) = ...    ! No elements: the lower bound is greater than the upper
x(5:1:-1) = ... ! Elements x(5), x(4), x(3), x(2), x(1)
x(::3) = ...    ! Elements x(1), x(4), x(7), x(10), assuming omitted bounds
x(::-3) = ...   ! No elements: the bounds are assumed with the first the lower, negative stride

जब एक स्ट्राइड (जो शून्य नहीं होना चाहिए) निर्दिष्ट किया जाता है, तत्वों का क्रम पहले बाउंड निर्दिष्ट के साथ शुरू होता है। यदि स्ट्राइड पॉजिटिव (रेस्पॉन्सिव) है तो सिलेक्ट एलीवेटेड (रिस्पॉन्स डिक्रिप्टेड) के बाद चुने हुए एलिमेंट्स तब तक स्ट्राइड करते हैं जब तक कि आखिरी एलिमेंट दूसरे बाउंड से बड़ा (रेस्पॉन्स छोटा) न हो जाए। यदि स्ट्राइड को छोड़ दिया जाता है तो इसे एक माना जाता है।

यदि पहला बाउंड दूसरे बाउंड से बड़ा है, और स्ट्राइड सकारात्मक है, तो कोई भी तत्व निर्दिष्ट नहीं है। यदि पहला बाउंड दूसरे बाउंड से छोटा है, और स्ट्राइड नकारात्मक है, तो कोई तत्व निर्दिष्ट नहीं है।

यह ध्यान दिया जाना चाहिए कि x(10:1:-1) x(1:10:1) के समान नहीं है, भले ही x का प्रत्येक तत्व दोनों मामलों में दिखाई देता है।

वेक्टर सदस्यताएँ

एक वेक्टर सबस्क्रिप्ट एक रैंक -1 पूर्णांक सरणी है। यह सरणी के मानों के अनुरूप तत्वों का एक क्रम निर्दिष्ट करता है।

real x(10)
integer i
x([1,6,4]) = ...     ! Elements x(1), x(6), x(4)
x([(i,i=2,4)]) = ... ! Elements x(2), x(3) and x(4)
print*, x([2,5,2])   ! Elements x(2), x(5) and x(2)

एक वेक्टर सबस्क्रिप्ट के साथ एक सरणी अनुभाग का उपयोग कैसे किया जा सकता है में प्रतिबंधित है:

• यह एक डमी तर्क से जुड़ा तर्क नहीं हो सकता है जो प्रक्रिया में परिभाषित है;
• यह एक सूचक असाइनमेंट स्टेटमेंट में लक्ष्य नहीं हो सकता है;
• यह डेटा ट्रांसफर स्टेटमेंट में आंतरिक फ़ाइल नहीं हो सकती है।

इसके अलावा, इस तरह के एक सरणी अनुभाग एक बयान में प्रकट नहीं हो सकता है जिसमें इसकी परिभाषा शामिल है जब एक ही तत्व दो बार चुना जाता है। ऊपर से:

print*, x([2,5,2])   ! Elements x(2), x(5) and x(2) are printed
x([2,5,2]) = 1.      ! Not permitted: x(2) appears twice in this definition

उच्च रैंक सरणी अनुभाग

real x(5,2)
print*, x(::2,2:1:-1)  ! Elements x(1,2), x(3,2), x(5,2), x(1,1), x(3,1), x(5,1)