Passing size as argument VS assuming shape in Fortran procedures

by

First, some terminology. Consider the dummy arguments declared as

real :: a(n)                ! An explicit shape array
real :: b(:)                ! An assumed shape array
real, allocatable :: c(:)   ! A deferred shape array (allocatable)
real, pointer :: d(:)       ! A deferred shape array (pointer)
real :: e(*)                ! An assumed size array
real :: f(..)               ! An assumed rank array/scalar

I won’t answer in terms of which is better in a given situation, but will simply detail some of the important characteristics leaving choice, where there is one, to the programmer. Crudely (and incorrectly), many view explicit shape arrays as “Fortran 77” and assumed and deferred shape arrays as “Fortran 90+”.

Assumed size and assumed rank arguments are beyond the scope of this question and answer.

Shape:

  • the shape of an explicit shape array follows its declaration;
  • the shape of an assumed shape array dummy argument is that of the actual argument;
  • the shape of a deferred shape dummy argument may be undefined, becoming defined in the procedure, or that of the actual argument.

Contiguousness:

  • an explicit shape array is simply contiguous;
  • an assumed shape array dummy argument’s contiguousness relates to that of the associated actual argument;
  • a deferred shape dummy argument may be that of the actual argument, or depending on the procedure’s execution.

Restrictions on actual argument:

  • an actual argument associated with an explicit shape array must have at least as many elements as the dummy argument;
  • an actual argument associated with an assumed shape array must not itself be assumed size;
  • an actual argument associated with an assumed or deferred shape array must be of the same rank as the dummy argument.

Interfaces in the calling scope:

  • if a dummy argument is of assumed or deferred shape, the referencing scope must have accessible an explicit interface for the procedure.

Consider real a(6). This may be an actual argument to the dummies

real b(3)
real c(2,3)
real d(:)   ! With an explicit interface available

a(1::2) may be associated with b but as b is contiguous copy-in/copy-out will be involved. Copy-in/copy-out needn’t be involved when associated with d, but it may be.

There are plenty of other aspects, but hopefully this is an initial high-level introduction.

More Related Contents:

  1. Line truncated, Syntax error in argument list
  2. How to pass subroutine names as arguments in Fortran?
  3. Fortran running error
  4. Why Segmentation fault is happening in this openmp code?
  5. Unexpected “padding” in a Fortran unformatted file
  6. What is an undefined reference/unresolved external symbol error and how do I fix it in Fortran?
  7. Correct use of modules, subroutines and functions in Fortran
  8. Is There a Better Double-Precision Assignment in Fortran 90?
  9. MPI_Recv overwrites parts of memory it should not access
  10. Sending 2D arrays in Fortran with MPI_Gather
  11. Print to standard output from a function defined in an Fortran module
  12. Why is this a function declared inside the module and then used somewhere else in the same module not seen by the linker?
  13. Does Fortran have undefined behavior?
  14. How to alias a function name in Fortran
  15. Reading data file in Fortran with known number of lines but unknown number of entries in each line
  16. What are the ways to pass a set of variable values through the subroutine to a function without common block?
  17. How can a scalar be passed to a vector (1D array) to a Fortran subroutine?
  18. What does “real*8” mean?
  19. Fortran IF statement with numbers/labels rather than another statement
  20. Using a deferred-length character string to read user input
  21. Providing an argument that has not the TARGET attribute to a procedure with a dummy argument that has the TARGET attribute
  22. Difference between intent(out) and intent(inout)
  23. Fortran intent(inout) versus omitting intent
  24. Fortran array cannot be returned in function: not a DUMMY variable
  25. Is Fortran unable to do the addition between 865398.78 and -865398.78? Why the answer is -0.03?
  26. Using do loop in a Fortran 90 program to read different number of lines for n frames?
  27. Difference between local allocatable and automatic arrays
  28. Proper use of modules in Fortran
  29. Fortran SAVE statement
  30. MPI_Gather gives seg fault in the most basic code

Leave a Comment