sorting_sort: add fypp variable for simplifying code

Author: jvdp1

src/stdlib_sorting.fypp

@@ -385,30 +385,16 @@ module stdlib_sorting
 !! The generic subroutine interface implementing the `SORT` algorithm, based
 !! on the `introsort` of David Musser.
 
-#:for k1 in INT_KINDS
-        pure module subroutine ${k1}$_sort( array )
-!! Version: experimental
-!!
-!! `${k1}$_sort( array )` sorts the input `ARRAY` of type `INTEGER(${k1}$)`
-!! using a hybrid sort based on the `introsort` of David Musser.
-!! The algorithm is of order O(N Ln(N)) for all inputs.
-!! Because it relies on `quicksort`, the coefficient of the O(N Ln(N))
-!! behavior is small for random data compared to other sorting algorithms.
-            integer(${k1}$), intent(inout) :: array(0:)
-        end subroutine ${k1}$_sort
-
-#:endfor
-
-#:for k1 in REAL_KINDS
+#:for k1, t1 in IR_KINDS_TYPES
         pure module subroutine ${k1}$_sort( array )
 !! Version: experimental
 !!
-!! `${k1}$_sort( array )` sorts the input `ARRAY` of type `REAL(${k1}$)`
+!! `${k1}$_sort( array )` sorts the input `ARRAY` of type `${t1}$`
 !! using a hybrid sort based on the `introsort` of David Musser.
 !! The algorithm is of order O(N Ln(N)) for all inputs.
 !! Because it relies on `quicksort`, the coefficient of the O(N Ln(N))
 !! behavior is small for random data compared to other sorting algorithms.
-            real(${k1}$), intent(inout) :: array(0:)
+            ${t1}$, intent(inout) :: array(0:)
         end subroutine ${k1}$_sort
 
 #:endfor

src/stdlib_sorting_sort.fypp

@@ -1,4 +1,5 @@
 #:include "common.fypp"
+#:set IR_KINDS_TYPES = INT_KINDS_TYPES + REAL_KINDS_TYPES
 
 !! Licensing:
 !!
@@ -60,10 +61,10 @@ submodule(stdlib_sorting) stdlib_sorting_sort
 contains
 
 
-#:for k1 in INT_KINDS
+#:for k1, t1 in IR_KINDS_TYPES
 
     pure module subroutine ${k1}$_sort( array )
-! `${k1}$_sort( array )` sorts the input `ARRAY` of type `INTEGER(${k1}$)`
+! `${k1}$_sort( array )` sorts the input `ARRAY` of type `${t1}$`
 ! using a hybrid sort based on the `introsort` of David Musser. As with
 ! `introsort`, `${k1}$_sort( array )` is an unstable hybrid comparison
 ! algorithm using `quicksort` for the main body of the sort tree,
@@ -73,11 +74,11 @@ contains
 ! Because it relies on `quicksort`, the coefficient of the O(N Ln(N))
 ! behavior is typically small compared to other sorting algorithms.
 
-        integer(${k1}$), intent(inout) :: array(0:)
+        ${t1}$, intent(inout) :: array(0:)
 
         integer(int32) :: depth_limit
 
-        depth_limit = 2 * int( floor( log( real( size( array, kind=int64 ),  &
+        depth_limit = 2 * int( floor( log( real( size( array, kind=int_size),  &
                                                  kind=dp) ) / log(2.0_dp) ), &
                                kind=int32 )
         call introsort(array, depth_limit)
@@ -89,7 +90,7 @@ contains
 ! is fewer than or equal to `INSERT_SIZE`, `heapsort` if the completion
 ! of the `quicksort` is too slow as estimated from `DEPTH_LIMIT`,
 ! otherwise sorting is done by a `quicksort`.
-            integer(${k1}$), intent(inout) :: array(0:)
+            ${t1}$, intent(inout) :: array(0:)
             integer(int32), intent(in)     :: depth_limit
 
             integer(int_size), parameter :: insert_size = 16_int_size
@@ -115,10 +116,10 @@ contains
 
         pure subroutine partition( array, index )
 ! quicksort partition using median of three.
-            integer(${k1}$), intent(inout) :: array(0:)
+            ${t1}$, intent(inout) :: array(0:)
             integer(int_size), intent(out) :: index
 
-            integer(${k1}$) :: u, v, w, x, y
+            ${t1}$ :: u, v, w, x, y
             integer(int_size) :: i, j
 
 ! Determine median of three and exchange it with the end.
@@ -158,10 +159,10 @@ contains
 
         pure subroutine insertion_sort( array )
 ! Bog standard insertion sort.
-            integer(${k1}$), intent(inout) :: array(0:)
+            ${t1}$, intent(inout) :: array(0:)
 
             integer(int_size) :: i, j
-            integer(${k1}$)   :: key
+            ${t1}$ :: key
 
             do j=1_int_size, size(array, kind=int_size)-1
                 key = array(j)
@@ -178,10 +179,10 @@ contains
 
         pure subroutine heap_sort( array )
 ! A bog standard heap sort
-            integer(${k1}$), intent(inout) :: array(0:)
+            ${t1}$, intent(inout) :: array(0:)
 
             integer(int_size) :: i, heap_size
-            integer(${k1}$)   :: y
+            ${t1}$   :: y
 
             heap_size = size( array, kind=int_size )
 ! Build the max heap
@@ -201,11 +202,11 @@ contains
 
         pure recursive subroutine max_heapify( array, i, heap_size )
 ! Transform the array into a max heap
-            integer(${k1}$), intent(inout) :: array(0:)
+            ${t1}$, intent(inout) :: array(0:)
             integer(int_size), intent(in)  :: i, heap_size
 
             integer(int_size) :: l, r, largest
-            integer(${k1}$)   :: y
+            ${t1}$   :: y
 
             largest = i
             l = 2_int_size * i + 1_int_size
@@ -230,177 +231,6 @@ contains
 #:endfor
 
 
-#:for k1 in REAL_KINDS
-
-    pure module subroutine ${k1}$_sort( array )
-
-! `${k1}$_sort( array )` sorts the input `ARRAY` of type `REAL(${k1}$)`
-! using a hybrid sort based on the `introsort` of David Musser. As with
-! `introsort`, `${k1}$_sort( array )` is an unstable hybrid comparison
-! algorithm using `quicksort` for the main body of the sort tree,
-! supplemented by `insertion sort` for the outer brances, but if
-! `quicksort` is converging too slowly the algorithm resorts
-! to `heapsort`. The algorithm is of order O(N Ln(N)) for all inputs.
-! Because it relies on `quicksort`, the coefficient of the O(N Ln(N))
-! behavior is typically small compared to other sorting algorithms.
-
-        real(${k1}$), intent(inout) :: array(0:)
-        integer(int32)              :: depth_limit
-
-        depth_limit = &
-            2 * int( floor( log( real( size( array, kind=int_size ),   &
-                                             kind=dp) ) / log(2.0_dp) ), &
-                               kind=int32 )
-        call introsort(array, depth_limit)
-
-    contains
-
-        pure recursive subroutine introsort( array, depth_limit )
-! It devolves to `insertionsort` if the remaining number of elements
-! is fewer than or equal to `INSERT_SIZE`, `heapsort` if the completion of
-! the quicksort is too slow as estimated from `DEPTH_LIMIT`, otherwise
-! sorting is done by a `quicksort`.
-            real(${k1}$), intent(inout) :: array(0:)
-            integer(int32), intent(in)  :: depth_limit
-
-            integer(int_size), parameter :: insert_size = 16_int_size
-            integer(int_size)            :: index
-
-            if ( size(array, kind=int_size) <= insert_size ) then
-                ! May be best at the end of SORT processing the whole array
-                ! See Musser, D.R., “Introspective Sorting and Selection
-                ! Algorithms,” Software—Practice and Experience, Vol. 27(8),
-                ! 983–993 (August 1997).
-
-                call insertion_sort( array )
-
-            else if ( depth_limit == 0 ) then
-                call heap_sort( array )
-
-            else
-                call partition( array, index )
-                call introsort( array(0:index-1), depth_limit-1 )
-                call introsort( array(index+1:), depth_limit-1 )
-            end if
-
-        end subroutine introsort
-
-
-        pure subroutine partition( array, index )
-! quicksort partition using median of three.
-            real(${k1}$), intent(inout)    :: array(0:)
-            integer(int_size), intent(out) :: index
-
-            real(${k1}$)      :: u, v, w, x, y
-            integer(int_size) :: i, j
-
-! Determine median of three and exchange it with the end.
-            u = array( 0 )
-            v = array( size(array, kind=int_size)/2-1 )
-            w = array( size(array, kind=int_size)-1 )
-            if ( (u > v) .neqv. (u > w) ) then
-                x = u
-                y = array(0)
-                array(0) = array( size( array, kind=int_size ) - 1 )
-                array( size( array, kind=int_size ) - 1 ) = y
-            else if ( (v < u) .neqv. (v < w) ) then
-                x = v
-                y = array(size( array, kind=int_size )/2-1)
-                array(size( array, kind=int_size )/2-1) = &
-                    array(size( array, kind=int_size )-1)
-                array( size( array, kind=int_size )-1 ) = y
-            else
-                x = w
-            end if
-! Partition the array
-            i = -1_int_size
-            do j = 0_int_size, size(array, kind=int_size)-2
-                if ( array(j) <= x ) then
-                    i = i + 1
-                    y = array(i)
-                    array(i) = array(j)
-                    array(j) = y
-                end if
-            end do
-            y = array(i+1)
-            array(i+1) = array(size(array, kind=int_size)-1)
-            array(size(array, kind=int_size)-1) = y
-            index = i + 1
-
-        end subroutine partition
-
-        pure subroutine insertion_sort( array )
-! Bog standard insertion sort.
-            real(${k1}$), intent(inout) :: array(0:)
-
-            integer(int_size) :: i, j
-            real(${k1}$)      :: key
-
-            do j=1_int_size, size(array, kind=int_size)-1
-                key = array(j)
-                i = j - 1
-                do while( i >= 0 )
-                    if ( array(i) <= key ) exit
-                    array(i+1) = array(i)
-                    i = i - 1
-                end do
-                array(i+1) = key
-            end do
-
-        end subroutine insertion_sort
-
-        pure subroutine heap_sort( array )
-! A bog standard heap sort
-            real(${k1}$), intent(inout) :: array(0:)
-
-            integer(int_size) :: i, heap_size
-            real(${k1}$)      :: y
-
-            heap_size = size( array, kind=int_size )
-! Build the max heap
-            do i = (heap_size-2)/2_int_size, 0_int_size, -1_int_size
-                call max_heapify( array, i, heap_size )
-            end do
-            do i = heap_size-1, 1_int_size, -1_int_size
-! Swap the first element with the current final element
-                y = array(0)
-                array(0) = array(i)
-                array(i) = y
-! Sift down using max_heapify
-                call max_heapify( array, 0_int_size, i )
-            end do
-
-        end subroutine heap_sort
-
-        pure recursive subroutine max_heapify( array, i, heap_size )
-! Transform the array into a max heap
-            real(${k1}$), intent(inout)   :: array(0:)
-            integer(int_size), intent(in) :: i, heap_size
-
-            integer(int_size) :: l, r, largest
-            real(${k1}$)      :: y
-
-            largest = i
-            l = 2_int_size * i + 1_int_size
-            r = l + 1_int_size
-            if ( l < heap_size ) then
-                if ( array(l) > array(largest) ) largest = l
-            end if
-            if ( r < heap_size ) then
-                if ( array(r) > array(largest) ) largest = r
-            end if
-            if ( largest /= i ) then
-                y = array(i)
-                array(i) = array(largest)
-                array(largest) = y
-                call max_heapify( array, largest, heap_size )
-            end if
-
-        end subroutine max_heapify
-
-    end subroutine ${k1}$_sort
-
-#:endfor
 
 
     pure module subroutine char_sort( array )