Rename int_size to int_index in source code

Author: jvdp1

src/stdlib_sorting.fypp

@@ -137,7 +137,7 @@ module stdlib_sorting
     implicit none
     private
 
-    integer, parameter, public :: int_size = int64 !! Integer kind for indexing
+    integer, parameter, public :: int_index = int64 !! Integer kind for indexing
 
 ! Constants for use by tim_sort
     integer, parameter :: &
@@ -152,8 +152,8 @@ module stdlib_sorting
 !!
 !! Used to pass state around in a stack among helper functions for the
 !! `ORD_SORT` and `SORT_INDEX` algorithms
-        integer(int_size) :: base = 0
-        integer(int_size) :: len = 0
+        integer(int_index) :: base = 0
+        integer(int_index) :: len = 0
     end type run_type
 
     public ord_sort
@@ -313,7 +313,7 @@ module stdlib_sorting
 !!   Otherwise it is defined to be as specified by reverse.
 !!
 !! * index: a rank 1 array of sorting indices. It is an `intent(out)`
-!!   argument of the type `integer(int_size)`. Its size shall be the
+!!   argument of the type `integer(int_index)`. Its size shall be the
 !!   same as `array`. On return, if defined, its elements would
 !!   sort the input `array` in the direction specified by `reverse`.
 !!
@@ -324,7 +324,7 @@ module stdlib_sorting
 !!   storage, its use can significantly reduce the stack memory requirements
 !!   for the code. Its value on return is undefined.
 !!
-!! * iwork (optional): shall be a rank 1 integer array of kind `int_size`,
+!! * iwork (optional): shall be a rank 1 integer array of kind `int_index`,
 !!   and shall have at least `size(array)/2` elements. It is an
 !!   `intent(out)` argument to be used as "scratch" memory
 !!   for internal record keeping. If associated with an array in static
@@ -347,8 +347,8 @@ module stdlib_sorting
 !!        integer, intent(inout)         :: a(:)
 !!        integer(int32), intent(inout)  :: b(:) ! The same size as a
 !!        integer(int32), intent(out)    :: work(:)
-!!        integer(int_size), intent(out) :: index(:)
-!!        integer(int_size), intent(out) :: iwork(:)
+!!        integer(int_index), intent(out) :: index(:)
+!!        integer(int_index), intent(out) :: iwork(:)
 !!    ! Find the indices to sort a
 !!        call sort_index(a, index(1:size(a)),&
 !!            work(1:size(a)/2), iwork(1:size(a)/2))
@@ -365,8 +365,8 @@ module stdlib_sorting
 !!        integer, intent(inout)         :: a(:,:)
 !!        integer(int32), intent(in)     :: column
 !!        integer(int32), intent(out)    :: work(:)
-!!        integer(int_size), intent(out) :: index(:)
-!!        integer(int_size), intent(out) :: iwork(:)
+!!        integer(int_index), intent(out) :: index(:)
+!!        integer(int_index), intent(out) :: iwork(:)
 !!        integer, allocatable           :: dummy(:)
 !!        integer :: i
 !!        allocate(dummy(size(a, dim=1)))
@@ -389,8 +389,8 @@ module stdlib_sorting
 !!        type(a_type), intent(inout)    :: a_data(:)
 !!        integer(int32), intent(inout)  :: a(:)
 !!        integer(int32), intent(out)    :: work(:)
-!!        integer(int_size), intent(out) :: index(:)
-!!        integer(int_size), intent(out) :: iwork(:)
+!!        integer(int_index), intent(out) :: index(:)
+!!        integer(int_index), intent(out) :: iwork(:)
 !!    ! Extract a component of `a_data`
 !!        a(1:size(a_data)) = a_data(:) % a
 !!    ! Find the indices to sort the component
@@ -525,11 +525,11 @@ module stdlib_sorting
 !! using a hybrid sort based on the `"Rust" sort` algorithm found in `slice.rs`
 !! and returns the sorted `ARRAY` and an array `INDEX` of indices in the
 !! order that would sort the input `ARRAY` in the desired direction.
-            ${t1}$, intent(inout)                    :: array(0:)
-            integer(int_size), intent(out)           :: index(0:)
-            ${t2}$, intent(out), optional            :: work(0:)
-            integer(int_size), intent(out), optional :: iwork(0:)
-            logical, intent(in), optional            :: reverse
+            ${t1}$, intent(inout)                     :: array(0:)
+            integer(int_index), intent(out)           :: index(0:)
+            ${t2}$, intent(out), optional             :: work(0:)
+            integer(int_index), intent(out), optional :: iwork(0:)
+            logical, intent(in), optional             :: reverse
         end subroutine ${name1}$_sort_index
 
 #:endfor

src/stdlib_sorting_ord_sort.fypp

@@ -113,12 +113,12 @@ contains
         ${t3}$, intent(out), optional :: work(0:)
 
         ${t2}$, allocatable :: buf(:)
-        integer(int_size) :: array_size
+        integer(int_index) :: array_size
         integer :: stat
 
-        array_size = size( array, kind=int_size )
+        array_size = size( array, kind=int_index )
         if ( present(work) ) then
-            if ( size( work, kind=int_size) < array_size/2 ) then
+            if ( size( work, kind=int_index) < array_size/2 ) then
                 error stop "${name1}$_${sname}$_ord_sort: work array is too small."
             endif
 ! Use the work array as scratch memory
@@ -141,17 +141,17 @@ contains
 !! Returns the minimum length of a run from 32-63 so that N/MIN_RUN is
 !! less than or equal to a power of two. See
 !! https://svn.python.org/projects/python/trunk/Objects/listsort.txt
-            integer(int_size)             :: min_run
-            integer(int_size), intent(in) :: n
+            integer(int_index)             :: min_run
+            integer(int_index), intent(in) :: n
 
-            integer(int_size) :: num, r
+            integer(int_index) :: num, r
 
             num = n
-            r = 0_int_size
+            r = 0_int_index
 
             do while( num >= 64 )
-                r = ior( r, iand(num, 1_int_size) )
-                num = ishft(num, -1_int_size)
+                r = ior( r, iand(num, 1_int_index) )
+                num = ishft(num, -1_int_index)
             end do
             min_run = num + r
 
@@ -162,10 +162,10 @@ contains
 ! Sorts `ARRAY` using an insertion sort.
             ${t1}$, intent(inout) :: array(0:)
 
-            integer(int_size) :: i, j
+            integer(int_index) :: i, j
             ${t3}$ :: key
 
-            do j=1, size(array, kind=int_size)-1
+            do j=1, size(array, kind=int_index)-1
                 key = array(j)
                 i = j - 1
                 do while( i >= 0 )
@@ -185,13 +185,13 @@ contains
 !
 ! 1. len(-3) > len(-2) + len(-1)
 ! 2. len(-2) > len(-1)
-            integer(int_size) :: r
+            integer(int_index) :: r
             type(run_type), intent(in), target :: runs(0:)
 
-            integer(int_size) :: n
+            integer(int_index) :: n
             logical :: test
 
-            n = size(runs, kind=int_size)
+            n = size(runs, kind=int_index)
             test = .false.
             if (n >= 2) then
                 if ( runs( n-1 ) % base == 0 .or. &
@@ -240,10 +240,10 @@ contains
             ${t1}$, intent(inout) :: array(0:)
 
             ${t3}$ :: tmp
-            integer(int_size) :: i
+            integer(int_index) :: i
 
             tmp = array(0)
-            find_hole: do i=1, size(array, kind=int_size)-1
+            find_hole: do i=1, size(array, kind=int_index)-1
                 if ( array(i) ${signt}$= tmp ) exit find_hole
                 array(i-1) = array(i)
             end do find_hole
@@ -275,11 +275,11 @@ contains
             ${t1}$, intent(inout) :: array(0:)
             ${t3}$, intent(inout) :: buf(0:)
 
-            integer(int_size) :: array_size, finish, min_run, r, r_count, &
+            integer(int_index) :: array_size, finish, min_run, r, r_count, &
                 start
             type(run_type) :: runs(0:max_merge_stack-1), left, right
 
-            array_size = size(array, kind=int_size)
+            array_size = size(array, kind=int_index)
 
 ! Very short runs are extended using insertion sort to span at least
 ! min_run elements. Slices of up to this length are sorted using insertion
@@ -361,12 +361,12 @@ contains
 ! `ARRAY(0:)`. `MID` must be > 0, and < `SIZE(ARRAY)-1`. Buffer `BUF`
 ! must be long enough to hold the shorter of the two runs.
             ${t1}$, intent(inout) :: array(0:)
-            integer(int_size), intent(in)  :: mid
+            integer(int_index), intent(in)  :: mid
             ${t3}$, intent(inout) :: buf(0:)
 
-            integer(int_size) :: array_len, i, j, k
+            integer(int_index) :: array_len, i, j, k
 
-            array_len = size(array, kind=int_size)
+            array_len = size(array, kind=int_index)
 
 ! Merge first copies the shorter run into `buf`. Then, depending on which
 ! run was shorter, it traces the copied run and the longer run forwards
@@ -417,11 +417,11 @@ contains
 ! Reverse a segment of an array in place
             ${t1}$, intent(inout) :: array(0:)
 
-            integer(int_size) :: lo, hi
+            integer(int_index) :: lo, hi
             ${t3}$ :: temp
 
             lo = 0
-            hi = size( array, kind=int_size ) - 1
+            hi = size( array, kind=int_index ) - 1
             do while( lo < hi )
                 temp = array(lo)
                 array(lo) = array(hi)

src/stdlib_sorting_radix_sort.f90

@@ -13,11 +13,11 @@
 contains
 ! For int8, radix sort becomes counting sort, so buffer is not needed
     pure subroutine radix_sort_u8_helper(N, arr)
-        integer(kind=int_size), intent(in) :: N
+        integer(kind=int_index), intent(in) :: N
         integer(kind=int8), dimension(N), intent(inout) :: arr
-        integer(kind=int_size) :: i
+        integer(kind=int_index) :: i
         integer :: bin_idx
-        integer(kind=int_size), dimension(-128:127) :: counts
+        integer(kind=int_index), dimension(-128:127) :: counts
         counts(:) = 0
         do i = 1, N
             bin_idx = arr(i)
@@ -34,12 +34,12 @@ pure subroutine radix_sort_u8_helper(N, arr)
     end subroutine
 
     pure subroutine radix_sort_u16_helper(N, arr, buf)
-        integer(kind=int_size), intent(in) :: N
+        integer(kind=int_index), intent(in) :: N
         integer(kind=int16), dimension(N), intent(inout) :: arr
         integer(kind=int16), dimension(N), intent(inout) :: buf
-        integer(kind=int_size) :: i
+        integer(kind=int_index) :: i
         integer :: b, b0, b1
-        integer(kind=int_size), dimension(0:radix_mask) :: c0, c1
+        integer(kind=int_index), dimension(0:radix_mask) :: c0, c1
         c0(:) = 0
         c1(:) = 0
         do i = 1, N
@@ -65,12 +65,12 @@ pure subroutine radix_sort_u16_helper(N, arr, buf)
     end subroutine
 
     pure subroutine radix_sort_u32_helper(N, arr, buf)
-        integer(kind=int_size), intent(in) :: N
+        integer(kind=int_index), intent(in) :: N
         integer(kind=int32), dimension(N), intent(inout) :: arr
         integer(kind=int32), dimension(N), intent(inout) :: buf
-        integer(kind=int_size) :: i
+        integer(kind=int_index) :: i
         integer :: b, b0, b1, b2, b3
-        integer(kind=int_size), dimension(0:radix_mask) :: c0, c1, c2, c3
+        integer(kind=int_index), dimension(0:radix_mask) :: c0, c1, c2, c3
         c0(:) = 0
         c1(:) = 0
         c2(:) = 0
@@ -114,12 +114,12 @@ pure subroutine radix_sort_u32_helper(N, arr, buf)
     end subroutine radix_sort_u32_helper
 
     pure subroutine radix_sort_u64_helper(N, arr, buffer)
-        integer(kind=int_size), intent(in) :: N
+        integer(kind=int_index), intent(in) :: N
         integer(kind=int64), dimension(N), intent(inout) :: arr
         integer(kind=int64), dimension(N), intent(inout) :: buffer
-        integer(kind=int_size) :: i
+        integer(kind=int_index) :: i
         integer(kind=int64) :: b, b0, b1, b2, b3, b4, b5, b6, b7
-        integer(kind=int_size), dimension(0:radix_mask) :: c0, c1, c2, c3, c4, c5, c6, c7
+        integer(kind=int_index), dimension(0:radix_mask) :: c0, c1, c2, c3, c4, c5, c6, c7
         c0(:) = 0
         c1(:) = 0
         c2(:) = 0
@@ -202,8 +202,8 @@ pure module subroutine int8_radix_sort(array, reverse)
         integer(kind=int8), dimension(:), intent(inout) :: array
         logical, intent(in), optional :: reverse
         integer(kind=int8) :: item
-        integer(kind=int_size) :: i, N
-        N = size(array, kind=int_size)
+        integer(kind=int_index) :: i, N
+        N = size(array, kind=int_index)
         call radix_sort_u8_helper(N, array)
         if (optval(reverse, .false.)) then
             do i = 1, N/2
@@ -218,13 +218,13 @@ pure module subroutine int16_radix_sort(array, work, reverse)
         integer(kind=int16), dimension(:), intent(inout) :: array
         integer(kind=int16), dimension(:), intent(inout), target, optional :: work
         logical, intent(in), optional :: reverse
-        integer(kind=int_size) :: i, N, start, middle, end
+        integer(kind=int_index) :: i, N, start, middle, end
         integer(kind=int16), dimension(:), pointer :: buffer
         integer(kind=int16) :: item
         logical :: use_internal_buffer
-        N = size(array, kind=int_size)
+        N = size(array, kind=int_index)
         if (present(work)) then
-            if (size(work, kind=int_size) < N) then
+            if (size(work, kind=int_index) < N) then
                 error stop "int16_radix_sort: work array is too small."
             end if
             use_internal_buffer = .false.
@@ -270,13 +270,13 @@ pure module subroutine int32_radix_sort(array, work, reverse)
         integer(kind=int32), dimension(:), intent(inout) :: array
         integer(kind=int32), dimension(:), intent(inout), target, optional :: work
         logical, intent(in), optional :: reverse
-        integer(kind=int_size) :: i, N, start, middle, end
+        integer(kind=int_index) :: i, N, start, middle, end
         integer(kind=int32), dimension(:), pointer :: buffer
         integer(kind=int32) :: item
         logical :: use_internal_buffer
-        N = size(array, kind=int_size)
+        N = size(array, kind=int_index)
         if (present(work)) then
-            if (size(work, kind=int_size) < N) then
+            if (size(work, kind=int_index) < N) then
                 error stop "int32_radix_sort: work array is too small."
             end if
             use_internal_buffer = .false.
@@ -320,14 +320,14 @@ module subroutine sp_radix_sort(array, work, reverse)
         real(kind=sp), dimension(:), intent(inout), target :: array
         real(kind=sp), dimension(:), intent(inout), target, optional :: work
         logical, intent(in), optional :: reverse
-        integer(kind=int_size) :: i, N, pos, rev_pos
+        integer(kind=int_index) :: i, N, pos, rev_pos
         integer(kind=int32), dimension(:), pointer :: arri32
         integer(kind=int32), dimension(:), pointer :: buffer
         real(kind=sp) :: item
         logical :: use_internal_buffer
-        N = size(array, kind=int_size)
+        N = size(array, kind=int_index)
         if (present(work)) then
-            if (size(work, kind=int_size) < N) then
+            if (size(work, kind=int_index) < N) then
                 error stop "sp_radix_sort: work array is too small."
             end if
             use_internal_buffer = .false.
@@ -373,13 +373,13 @@ pure module subroutine int64_radix_sort(array, work, reverse)
         integer(kind=int64), dimension(:), intent(inout) :: array
         integer(kind=int64), dimension(:), intent(inout), target, optional :: work
         logical, intent(in), optional :: reverse
-        integer(kind=int_size) :: i, N, start, middle, end
+        integer(kind=int_index) :: i, N, start, middle, end
         integer(kind=int64), dimension(:), pointer :: buffer
         integer(kind=int64) :: item
         logical :: use_internal_buffer
-        N = size(array, kind=int_size)
+        N = size(array, kind=int_index)
         if (present(work)) then
-            if (size(work, kind=int_size) < N) then
+            if (size(work, kind=int_index) < N) then
                 error stop "int64_radix_sort: work array is too small."
             end if
             use_internal_buffer = .false.
@@ -423,14 +423,14 @@ module subroutine dp_radix_sort(array, work, reverse)
         real(kind=dp), dimension(:), intent(inout), target :: array
         real(kind=dp), dimension(:), intent(inout), target, optional :: work
         logical, intent(in), optional :: reverse
-        integer(kind=int_size) :: i, N, pos, rev_pos
+        integer(kind=int_index) :: i, N, pos, rev_pos
         integer(kind=int64), dimension(:), pointer :: arri64
         integer(kind=int64), dimension(:), pointer :: buffer
         real(kind=dp) :: item
         logical :: use_internal_buffer
-        N = size(array, kind=int_size)
+        N = size(array, kind=int_index)
         if (present(work)) then
-            if (size(work, kind=int_size) < N) then
+            if (size(work, kind=int_index) < N) then
                 error stop "sp_radix_sort: work array is too small."
             end if
             use_internal_buffer = .false.