Turn on suggestions

Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.

Showing results for

- Intel Community
- Software Development Tools (Compilers, Debuggers, Profilers & Analyzers)
- Intel® Fortran Compiler
- Passing Vector Segments to Assumed-sized Array

- Subscribe to RSS Feed
- Mark Topic as New
- Mark Topic as Read
- Float this Topic for Current User
- Bookmark
- Subscribe
- Mute
- Printer Friendly Page

Highlighted

hentall_maccuish__ja

Beginner

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content

04-01-2019
09:55 AM

7 Views

Hello,

I working some inhereted code that uses assumed-size arrays. I haven't worked with assumed-size assays before (I'm under the impression that assumed-shaped are preferrable and assumed-size only exist for backward compatibility) and the way they are used doesn't seem to fit neatly into the documentation I have found online about assumed-size arrays. What seems strange to me is that the main program has one long vector and single elements of this vector are passed into assumed-size array interface parameters of a subroutine. The ones of these that are of the format a(*) get created as vectors of length 1 but the ones that are of the form a(10,*) get created as arrays of shape (10,1). At least that is my understanding of how it behaves from reverse enginerring the code. So my question is, have I understod correctly and can I rely one the code to consitently behave this way? To make the question clear here is a code snippet

program test real ::X(100), y(5) call sub(x(1),x(10),x(50),y) contains subroutine sub(a,b,c) real:: a(*), b(10,*), c(*), d(*) end subroutine sub end program test

So in this example I a and c are of shape (1), b is of shape (10,1) and d is of shape (5). I've seen documentation explaining why d would be (5) but not confirming b should always be (10,1).

Thanks in advance

Accepted Solutions

Highlighted

Steve_Lionel

Retired Employee

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content

04-01-2019
10:39 AM

7 Views

The extent of the last dimension of a,b,c and d are, technically, 100, 9, 51, 5, but there's no way to determine that in the program. Passing a single element to an assumed-size array is called "sequence association", and the dummy argument (a,b,c,d) is associated with the remainder of the extent of the actual argument. (b is a bit strange - as there is actually one more element left over. Your example would have been easier to explain if the subscripts were 11 and 51.)

In pre-F77 days, it was popular to declare dummy arrays with a last bound of 1, relying on the lack of bounds checking in most early compilers. F77 added assumed-size arrays which replace the (1) hack.

Here's what the standard says (8.5.8.5):

The size of an assumed-size array is determined as follows.

• If the effective argument associated with the assumed-size dummy array is an array of any type other than default character, the size is that of the effective argument.

• If the actual argument corresponding to the assumed-size dummy array is an array element of any type other than default character with a subscript order value of r (9.5.3.2) in an array of size x, the size of the dummy array is x − r + 1.

• If the actual argument is a default character array, default character array element, or a default character array element substring (9.4.1), and if it begins at character storage unit t of an array with c character storage units, the size of the dummy array is MAX (INT ((c − t + 1)/e), 0), where e is the length of an element in the dummy character array.

• If the actual argument is a default character scalar that is not an array element or array element substring designator, the size of the dummy array is MAX (INT (l/e), 0), where e is the length of an element in the dummy character array and l is the length of the actual argument.

--

Steve (aka "Doctor Fortran") - https://stevelionel.com/drfortran

Steve (aka "Doctor Fortran") - https://stevelionel.com/drfortran

3 Replies

Highlighted

Steve_Lionel

Retired Employee

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content

04-01-2019
10:39 AM

8 Views

The extent of the last dimension of a,b,c and d are, technically, 100, 9, 51, 5, but there's no way to determine that in the program. Passing a single element to an assumed-size array is called "sequence association", and the dummy argument (a,b,c,d) is associated with the remainder of the extent of the actual argument. (b is a bit strange - as there is actually one more element left over. Your example would have been easier to explain if the subscripts were 11 and 51.)

In pre-F77 days, it was popular to declare dummy arrays with a last bound of 1, relying on the lack of bounds checking in most early compilers. F77 added assumed-size arrays which replace the (1) hack.

Here's what the standard says (8.5.8.5):

The size of an assumed-size array is determined as follows.

• If the effective argument associated with the assumed-size dummy array is an array of any type other than default character, the size is that of the effective argument.

• If the actual argument corresponding to the assumed-size dummy array is an array element of any type other than default character with a subscript order value of r (9.5.3.2) in an array of size x, the size of the dummy array is x − r + 1.

• If the actual argument is a default character array, default character array element, or a default character array element substring (9.4.1), and if it begins at character storage unit t of an array with c character storage units, the size of the dummy array is MAX (INT ((c − t + 1)/e), 0), where e is the length of an element in the dummy character array.

• If the actual argument is a default character scalar that is not an array element or array element substring designator, the size of the dummy array is MAX (INT (l/e), 0), where e is the length of an element in the dummy character array and l is the length of the actual argument.

--

Steve (aka "Doctor Fortran") - https://stevelionel.com/drfortran

Steve (aka "Doctor Fortran") - https://stevelionel.com/drfortran

Highlighted
##

Jump to solution
Thanks you! That is really helpful and very different from what I had inferred from how the assumed-size arrays get presented in the debugger

hentall_maccuish__ja

Beginner

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content

04-02-2019
02:13 AM

7 Views

Thanks you! That is really

Highlighted
##

Jump to solution

Steve_Lionel

Retired Employee

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Email to a Friend
- Report Inappropriate Content

04-02-2019
06:08 AM

7 Views

The debugger shows them as (1

The debugger shows them as (1) because it has no information about the actual bounds.

--

Steve (aka "Doctor Fortran") - https://stevelionel.com/drfortran

Steve (aka "Doctor Fortran") - https://stevelionel.com/drfortran

For more complete information about compiler optimizations, see our Optimization Notice.