परस्पर निर्भर आयामों के साथ गतिशील सरणी आवंटित करें

Question

यह थोड़ा जटिल है; प्रश्न की स्पष्टता में सुधार करने के तरीके पर मैं किसी भी टिप्पणी का स्वागत करता हूं।

ठीक है, मैं एक सरणी है कहते हैं:

real, allocatable :: A(:,:,:) 

और मैं इसे आवंटित करने के लिए इससे पहले कि मैं इसका इस्तेमाल करना चाहते हैं। क्या दूसरे आयाम के आकार पर निर्भर करने के लिए तीसरे आयाम के आकार के लिए यह संभव है?

उदा।

do i=1,n 
allocate(A(3,i,i**2)) 
end do 

स्पष्ट रूप से उपर्युक्त काम नहीं करता है। मैं एक सरणी (या सरणियों का एक सेट) आकार (रों)

(3,1,1), (3,2,4), (3,3,9), ... (3, n, n^2) 

जहां तीसरे आयाम का आकार दूसरे आयाम के आकार का वर्ग है साथ साथ खत्म करना चाहते हैं।

आश्रित आयाम के आकार के लिए मेरा नियम थोड़ा अधिक जटिल है, लेकिन अगर स्क्वायरिंग संभव है तो मैं बाकी कर सकता हूं।

क्या यह संभव है? यदि हां, तो मैं इसे फोरट्रान में कैसे कार्यान्वित कर सकता हूं?

shape(A) वापसी क्या होगी? यह दिलचस्प होगा।

मेरे अन्य वैकल्पिक, अधिकतम आकार के लिए आवश्यक करने के लिए आवंटित है, और केवल इस समय

allocate(A(3,n,n**2)) 

गणना में कुछ तत्वों का उपयोग करें, यानी भले ही मैं कठिन स्मृति पर नहीं कर रहा हूँ करने के लिए सावधान रहना है मैं अच्छा प्रोग्रामिंग प्रथाओं की तरह होना पसंद है। वैसे भी यह एक दिलचस्प समस्या है।

धन्यवाद।

संपादित करें:

क्या एक आयाम के आकार होने के बारे में मूल्य एक और आयाम में एक तत्व की पर निर्भर करते हैं?

दोनों आयामों में सरणी के आकार के नीचे जवाब में बी मैं के सूचकांक पर निर्भर

type myarray 
    real :: coord(3) 
    integer,allocatable :: lev(:) 
    integer, allocatable :: cell(:) 
endtype myarray 

type(myarray), allocatable :: data 

allocate(data(m)) 
allocate(data%lev(n)) 

forall (j=1:n) !simple now, for argument's sake 
    lev(j)=j 
endforall 

! I was thinking of using a FORALL loop here, but the errors returned 
! suggested that the compiler (gfortran) didn't expect IF blocks and ALLOCATE 
! statements in a FORALL block 
do i=1,m 
    do j=1,n 
     allocate(data(i)%cell(lev(j)**2)) 
    enddo 
enddo 

आप प्राप्त की तर्ज पर कुछ करना चाहते हैं कि मैं क्या मतलब है? लेकिन कार्यक्रम खत्म हो गया है क्योंकि यह पहले से आवंटित चर आवंटित करने का प्रयास करता है, उदा। जब i=1 यह data(1)%cell(1) आवंटित करता है, और फिर data(1)%cell(2) आवंटित करने का प्रयास करता है ... ओह ओह।

प्रत्येक data(i) 1 से n करने के लिए चल रहे मूल्यों की एक सरणी lev(j), j साथ हैं, और प्रत्येक lev(j) मूल्य के लिए हम आकार lev^2 के एक cell है: क्या मैं चाहता हूँ की तरह कुछ है। ध्यान दें कि ये cell प्रत्येक data(i) और प्रत्येक lev के लिए अद्वितीय हैं, और उस विशेष cell का आकार इसी lev मान पर निर्भर करता है, और संभवतः संबंधित data(i) पर भी निर्भर करता है।

क्या मुझे व्युत्पन्न प्रकार के भीतर व्युत्पन्न प्रकार का उपयोग करना होगा?

Answer 1

हाँ, आप यह पूरा करने के एक व्युत्पन्न प्रकार का उपयोग कर सकते हैं:

TYPE array 
    REAL,DIMENSION(:,:,:),ALLOCATABLE :: A 
ENDTYPE array 

INTEGER :: i 
INTEGER,PARAMETER :: n=10 

TYPE(array),DIMENSION(:),ALLOCATABLE :: B 

ALLOCATE(B(n)) 

DO i=1,n 
    ALLOCATE(B(i)%A(3,i,i*i)) 
    WRITE(*,*)SHAPE(B(i)%A) 
ENDDO 

END 

यह दृष्टिकोण सरणी बी के प्रत्येक तत्व एक अलग आकार के एक बहु-आयामी सरणी होने की अनुमति देता है।

कार्यक्रम के उत्पादन की उम्मीद है:

 3   1   1 
     3   2   4 
     3   3   9 
     3   4   16 
     3   5   25 
     3   6   36 
     3   7   49 
     3   8   64 
     3   9   81 
     3   10   100 

संपादित करें: आगे ओपी के संपादित सवाल का जवाब करने के लिए।

integer,parameter :: m=3,n=5 

type cellarray 
    integer,dimension(:),allocatable :: c 
endtype cellarray 

type myarray 
    integer,allocatable :: lev(:) 
    type(cellarray),dimension(:),allocatable :: cell 
endtype myarray 

type(myarray),dimension(:),allocatable :: B 

allocate(B(m)) 

! Allocate and assign lev and cell: 
do i=1,m 
    allocate(B(i)%lev(n)) 
    allocate(B(i)%cell(n)) 
    do j=1,n 
    B(i)%lev(j)=j 
    enddo 
enddo 

! Based on value of lev, allocate B%cell%c:  
do i=1,m 
    do j=1,n 
    allocate(B(i)%cell(j)%c(B(i)%lev(j)**2)) 
    enddo 
enddo 

! Print out to check that it works: 
do j=1,n 
    write(*,*)j,B(1)%lev(j),SIZE(B(1)%cell(j)%c) 
enddo 

end 

gfortran 4.6.2 के साथ इस की कोशिश की: हाँ, ऐसा लगता है कि आप इस तरह से कुछ करने के लिए की आवश्यकता होगी, का उपयोग नेस्ट व्युत्पन्न प्रकार (अपने कोड उदाहरण से तुलना यह पता लगाने की क्या तुम गलत किया था) लगता है। यह उम्मीद उत्पादन का उत्पादन:

 1   1   1 
     2   2   4 
     3   3   9 
     4   4   16 
     5   5   25 

Answer 2

मुझे लगता है कि आप बस आवंटन/सरणी

Program test 
    Implicit none 
    Real, dimension(:,:,:), allocatable :: A 
    Integer :: i,N 
    Write(*,*)"Enter N"; Read(*,*)N 
    Do i = 1, N 
    if(Allocated(A)) then 
    deallocate(A);Allocate(A(i,i,i*i)) 
    else 
    allocate(A(i,i,i*i)) 
    end if 
    Write(*,*)Shape(A) 
    End do 
end program test 

देता gfortran का उपयोग कर कार्यक्रम संकलन deallocating करके ऐसा कर सकते:

Enter N 
5 
      1   1   1 
      2   2   4 
      3   3   9 
      4   4   16 
      5   5   25