Does MINLOC work for arrays beginning at index 0? (Fortran 90/95)

Question

After using C for a while, I went back to Fortran and allocated the arrays in my code from index 0 to N:

real(kind=dp), dimension(:), allocatable :: a 
allocate(a(0:50))

I needed to find the index of the minimum absolute value of the array, so I used MINLOC, and to check this I compared it to MINVAL:

minloc(abs(a(:)))
minval(abs(a))

The result of MINLOC was index 42 but the result of MINVAL corresponded to 41. Here is the relevant section from the output:

Index i    a(i) 

39         0.04667    
40         0.02222    
41         0.00222           !This was clearly the minimum value
42         0.02667

MINLOC = 42
MINVAL = 0.00222

I assume this is something to do with the Fortran intrinsic not handling arrays with index 0 correctly, since it is not standard Fortran style to declare arrays in this way (but it is still permitted!).

Can anyone confirm this or offer a workaround?

Answer 1

Your array a indeed starts at index 0, but you did not use that. You searched for a minimum of array abs(a(:)). This anonymous array expression starts at 1 as all arrays do by default.

But even if you used a the result would be the same and is consistent with how array argument passing works in Fortran.

The Fortran standard clearly states:

The i subscript returned lies in the range 1 to ei , where ei is the extent of the idimension of ARRAY. If ARRAY has size zero, all elements of the result are zero.

Lower bounds are not automatically passed with the array if you used assumed shape arguments. For example if you have your own function

  function f(arg)
    real :: arg(:)

arg starts always at 1 no matter where the actual argument started in the calling code.

You can change it to start at some other value

  function f(arg)
    real :: arg(-42:)

and it would be indexed starting from that value.

Answer 2

There are two simple methods to handle complication of adjusting the indices obtained from minloc(): One is simply adding lbound() - 1 for all indices, and the other is using an array pointer with 1-based indices. An example code may look like this:

program test
implicit none
integer, allocatable, target :: a(:,:)
integer, pointer :: anew(:,:)
integer :: loc(2)

allocate( a( 0:4, 2:5 ), source= 10 )  !! make an array filled with 10

a( 2, 3 ) = -700                       !! set the minimum value

loc(:) = minloc( a )                   !! minloc() receives "a" with 1-based indices
print *, loc(:)                        !! so we get [3,2]
print *, a( loc(1), loc(2) )           !! 10 (wrong result...)

!! Method (1) : adjust indices manually

loc(:) = loc(:) + lbound( a ) - 1
print *, a( loc(1), loc(2) )           !! -700 (now a correct result)

!! Method (2) : use array pointer with 1-based indices

anew( 1:, 1: ) => a

loc(:) = minloc( anew )
print *, loc(:)                        !! we get [3,2] again
print *, anew( loc(1), loc(2) )        !! -700  (this time, no need to adjust indices)

end program