Arrays are a central object in Fortran. The creation of dynamic sized arrays is discussed in the allocatable arrays section.
To pass arrays to procedures four ways are available
The preferred way to pass arrays to procedures is as assumed-shape arrays
subroutine f(r)
real(dp), intent(out) :: r(:)
integer :: n, i
n = size(r)
do i = 1, n
r(i) = 1.0_dp / i**2
end do
end subroutine f
Higher-dimensional arrays can be passed in a similar way.
subroutine g(A)
real(dp), intent(in) :: A(:, :)
...
end subroutine g
The array is simply passed by
real(dp) :: r(5)
call f(r)
In this case no array copy is done, which has the advantage that the shape and size information is automatically passed along and checked at compile and optionally at runtime. Similarly, array strides can be passed without requiring a copy of the array but as assumed-shape descriptor:
real(dp) :: r(10)
call f(r(1:10:2))
call f(r(2:10:2))
This should always be your default way of passing arrays in and out of subroutines. Avoid passing arrays as whole slices, as it obfuscates the actual intent of the code:
real(dp) :: r(10)
call f(r(:))
In case more general arrays should be passed to a procedure the assumed-rank functionality introduced in the Fortran 2018 standard can be used
subroutine h(r)
real(dp), intent(in) :: r(..)
select rank(r)
rank(1)
! ...
rank(2)
! ...
end select
end subroutine h
The actual rank can be queried at runtime using the select rank construct.
This easily allows to create more generic functions that have to deal with
different array ranks.
Explicit-shape arrays can be useful for returning data from functions. Most of their functionality can be provided by assumed-shape and assumed-rank arrays but they find frequent use for interfacing with C or in legacy Fortran procedures, therefore they will be discussed briefly here.
To use explicit-shape arrays, the dimension has to be passed explicitly as dummy argument like in the example below
subroutine f(n, r)
integer, intent(in) :: n
real(dp), intent(out) :: r(n)
integer :: i
do i = 1, n
r(i) = 1.0_dp / i**2
end do
end subroutine
For high-dimensional arrays additional indices have to be passed.
subroutine g(m, n, A)
integer, intent(in) :: m, n
real(dp), intent(in) :: A(m, n)
...
end subroutine
The routines can be invoked by
real(dp) :: r(5), s(3, 4)
call f(size(r), r)
call g(size(s, 1), size(s, 2), s)
Note that the shape is not checked, so the following would be legal code that will potentially yield incorrect results:
real(dp) :: s(3, 4)
call g(size(s), 1, s) ! s(12, 1) in g
call g(size(s, 2), size(s, 1), s) ! s(4, 3) in g
In this case the memory layout is preserved but the shape is changed. Also, explicit-shape arrays require contiguous memory and will create temporary arrays in case non-contiguous array strides are passed.
To return an array from a function with explicit-shape use
function f(n) result(r)
integer, intent(in) :: n
real(dp) :: r(n)
integer :: i
do i = 1, n
r(i) = 1.0_dp / i**2
end do
end function
Finally, there are assumed-size arrays, which provide the least compile-time and run-time
checking and can be found frequently in legacy code. They should be avoided
in favour of assumed-shape or assumed-rank arrays.
An assumed-size array dummy argument is identified by an asterisk as the last dimension,
this disables the usage of this array with many intrinsic functions, like size or
shape.
To check for the correct size and shape of an assumed-shape array the size and
shape intrinsic functions can be used to query for those properties
if (size(r) /= 4) error stop "Incorrect size of 'r'"
if (any(shape(r) /= [2, 2])) error stop "Incorrect shape of 'r'"
Note that size returns the total size of all dimensions. To obtain the shape of
a specific dimension add it as second argument to the function.
Arrays can be initialized by using an array constructor
integer :: r(5)
r = [1, 2, 3, 4, 5]
The array constructor can be annotated with the type of the constructed array
real(dp) :: r(5)
r = [real(dp) :: 1, 2, 3, 4, 5]
Implicit do loops can be used inside an array constructor as well
integer :: i
real(dp) :: r(5)
r = [(real(i**2, dp), i = 1, size(r))]
In order for the array to start with different index than 1, do:
subroutine print_eigenvalues(kappa_min, lam)
integer, intent(in) :: kappa_min
real(dp), intent(in) :: lam(kappa_min:)
integer :: kappa
do kappa = kappa_min, ubound(lam, 1)
print *, kappa, lam(kappa)
end do
end subroutine print_eigenvalues