Can fortran infer shape of array passed to subroutine? - fortran

Question

I read that Fortran (unlike C) knows the size of arrays, and can infer it when I pass the array into function (subroutine). But I cannot make it work.
Minimum example:
program.f90
program test_arrayPass
! === variables
integer :: n
real, dimension (:,:),allocatable :: data
! === Body
n = 3
allocate(data(n,n))
write (*,*) "DEBUG test_arrayPass : shape(data) ", shape(data)
call writeToArray( data )
end
writeToArray.f90
subroutine writeToArray( data )
real , dimension(:,:), intent(out) :: data ! none of these works
!real , dimension(:,:), intent(in) :: data ! none of these works
!real , dimension(*,*), intent(in) :: data ! none of these works
write (*,*) "DEBUG writeToArray : shape(data) ", shape(data)
end
Makefile
FC := /usr/bin/gfortran
FCFLAGS = -g -Og -c -fdefault-real-8 -fbacktrace -fno-align-commons -fbounds-check
FLFLAGS =
SRCS = $(patsubst %.f90, %.o, $(wildcard *.f90))
PROGRAM = program
all: $(PROGRAM)
$(PROGRAM): $(SRCS)
$(FC) $(FLFLAGS) -o $# $^
%.o: %.f90
$(FC) $(FCFLAGS) -o $# $<
clean:
rm -f *.o *.mod
Result
with dimension(:,:) it does not know corret size inside writeToArray()
DEBUG test_arrayPass : shape(data) 3 3
DEBUG writeToArray : shape(data) 1 0
with dimension(*,*) it produces error
5 | real , dimension(*,*), intent(in) :: data
| 1
Error: Non-PARAMETER symbol ‘data’ at (1) cannot be implied-shape

Answer 1

Fortran can indeed assume (not infer) the shape or size of a dummy argument.
Assuming shape and size are two different things, with different requirements. With the dummy argument (intent doesn't matter)
real , dimension(:,:), intent(out) :: data
you are assuming its shape (by using : in the declaration). The problem you are seeing with this attempt is that you do not provide an explicit interface in your main program. This is such a common mistake that has been covered many times here that I won't expand more: searching for "explicit interface" will provide lots of ideas.
Instead, I'll talk about your other attempt:
real , dimension(*,*), intent(in) :: data
This isn't assuming the argument's shape, and neither is it assuming its size. An assumed size dummy argument would look like
real , dimension(*), intent(in) :: data
or
real , dimension(3,*), intent(in) :: data
In an assumed size array you can only have "unknown" extent in one of the ranks, and that must be the final one. However, the syntax for an implied-shape array is as you have, but only named constants (and not dummy arguments) may be implied-shape. Your compiler is complaining about this error, not thinking you are trying to talk about an assumed-size dummy array.
Assumed-size array arguments don't require such an explicit interface, but to make this work you'll need to assume just one dimension. (You can make associate a rank-2 array with a rank-1 assumed-size dummy argument if you don't want to guess one of the extents in the subroutine.)
But unless you have a really good reason you want to use an assumed-shape (:,:) array with an explicit interface. (If you have a good reason to use an implicit interface, you need to think very hard about whether you should be doing what you are doing.)
Finally, with an assumed-size array, you can't inquire of the shape of the array (using shape), its size (size) or its upper bounds (ubound). For size and upper bound you can ask about these properties of the initial extents, just not the final. You can use an assumed-size array, but you'll need some other source of information about its shape.

Answer 2

Minimal working example:
program test_arrayPass
! === variables
integer :: n
real, dimension (:,:),allocatable :: data
! === Body
n = 3
allocate(data(n,n))
write (*,*) "DEBUG test_arrayPass : shape(data) ", shape(data)
call writeToArray( data )
contains
subroutine writeToArray( data )
! === variables
real , dimension(:,:), intent(out) :: data
integer :: n, m, k
! === Body
write (*,*) "DEBUG writeToArray : shape(data) ", shape(data)
n = size(data,1)
m = size(data,2)
data = reshape( [(real(k), k=1,n*m)], [n,m] )
end subroutine
end program
The problem with your code is that the subroutine writeToArray is declared outside the scope of the program. You either contain it within the program, or you put in a module.