Function to return positions of new elements?

[Beliavsky]

To list the unique elements of a 1D array, one can sort the array and then find the positions of new elements. This is a common task -- should it be added to stdlib with a name such as new_loc? Here is an implementation for an array of integers.

module m_mod
implicit none
contains
pure function new_loc(vec) result(ipos)
! return the positions of the new elements in vec(:), including the first element
integer, intent(in)  :: vec(:)
integer, allocatable :: ipos(:)
integer              :: i,inew,n,nnew
n = size(vec)
if (n == 0) then
   allocate (ipos(0))
   return
else if (n == 1) then
   ipos = [1]
   return
end if
nnew = count(vec(2:) /= vec(:n-1)) + 1
allocate (ipos(nnew))
ipos(1) = 1
inew = 1
do i=2,n
   if (vec(i) /= vec(i-1)) then
      inew = inew + 1
      ipos(inew) = i
   end if
end do
end function new_loc
end module m_mod
!
program xnew_loc
use m_mod, only: new_loc
print*,new_loc([3])
print*,new_loc([3,3,1,1,2])
print*,new_loc([integer ::]) ! test on zero-sized array
print*,"done"
end program xnew_loc

gives output

           1
           1           3           5

 done

[gareth-nx]

IMO this is one of a number of things that would be nice, and would naturally leverage the sorting module which will hopefully soon be committed.

Some possibilities that I've used in the past:

• unique_value_indices(x) - return the (first) indices of the unique elements of an intent(in) array x. This is like the new_loc you suggest above, but not requring that the input array is sorted -- although an optional argument is_sorted could be used to treat that case.
• unique_values(x) - return the unique elements of an intent(in) array x
• match(x, y) - for each entry in x, return the first index of the matching entry in y (or -1 if there is no match). Like the R function of the same name.
• which(x) - return the indices of a logical array x that are .true. -- also something I find useful in R.
• rle(x) -- like this R function -- it can be used to compactly represent arrays that tend to repeat consecutive values.

[gareth-nx]

• should it be added to stdlib with a name such as new_loc? Here is an implementation for an array of integers.

An alternative approach that is quite succinct is to build on the intrinsic function pack:

program pack_example
    implicit none
    integer, allocatable :: x(:)
    integer, allocatable :: ivec(:), new_loc(:)
    integer :: i

    x = [3, 3, 1, 1, 2] ! As in previous example
    ! Compute the new indices
    ivec = (/ ( i, i = 1, size(x) ) /)
    new_loc = [1, 1+pack(ivec, x(2:size(x)) /= x(1:size(x)-1))]
    print*, new_loc
end program

which prints

        1           3           5