Merge pull request #1 from jvdp1/sorting_fypp_proposition_2

Proposition to generate code for integer, real and string from one single peace of code

Author: wclodius2

src/common.fypp

@@ -3,7 +3,7 @@
 #! Real kinds to be considered during templating
 #:set REAL_KINDS = ["sp", "dp", "qp"]
 
-#! Real types to be considere during templating
+#! Real types to be considered during templating
 #:set REAL_TYPES = ["real({})".format(k) for k in REAL_KINDS]
 
 #! Collected (kind, type) tuples for real types
@@ -12,7 +12,7 @@
 #! Complex kinds to be considered during templating
 #:set CMPLX_KINDS = ["sp", "dp", "qp"]
 
-#! Complex types to be considere during templating
+#! Complex types to be considered during templating
 #:set CMPLX_TYPES = ["complex({})".format(k) for k in CMPLX_KINDS]
 
 #! Collected (kind, type) tuples for complex types
@@ -21,12 +21,21 @@
 #! Integer kinds to be considered during templating
 #:set INT_KINDS = ["int8", "int16", "int32", "int64"]
 
-#! Integer types to be considere during templating
+#! Integer types to be considered during templating
 #:set INT_TYPES = ["integer({})".format(k) for k in INT_KINDS]
 
 #! Collected (kind, type) tuples for integer types
 #:set INT_KINDS_TYPES = list(zip(INT_KINDS, INT_TYPES))
 
+#! Derived type string_type
+#:set STRING_KINDS = ["string_type"]
+
+#! String types to be considered during templating
+#:set STRING_TYPES = ["type({})".format(k) for k in STRING_KINDS]
+
+#! Collected (kind, type) tuples for string derived types
+#:set STRING_KINDS_TYPES = list(zip(STRING_KINDS, STRING_TYPES))
+
 
 #! Whether Fortran 90 compatible code should be generated
 #:set VERSION90 = defined('VERSION90')

src/stdlib_sorting.fypp

@@ -1,4 +1,5 @@
 #:include "common.fypp"
+#:set IRS_KINDS_TYPES = INT_KINDS_TYPES + REAL_KINDS_TYPES + STRING_KINDS_TYPES
 
 !! Licensing:
 !!
@@ -326,11 +327,11 @@ module stdlib_sorting
 
     public char_sort_index
 
-    public string_ord_sort
+    public string_type_ord_sort
 
-    public string_sort
+    public string_type_sort
 
-    public string_sort_index
+    public string_type_sort_index
 
     interface ord_sort
 !! Version: experimental
@@ -346,29 +347,18 @@ module stdlib_sorting
 !! sorted data, having O(N) performance on uniformly non-increasing or
 !! non-decreasing data.
 
-#:for k1 in INT_KINDS
+#:for k1, t1 in IRS_KINDS_TYPES
         module subroutine ${k1}$_ord_sort( array, work )
 !! Version: experimental
 !!
-!! `${k1}$_ord_sort( array )` sorts the input `ARRAY` of type `INTEGER(${k1}$)`
+!! `${k1}$_ord_sort( array )` sorts the input `ARRAY` of type `${t1}$`
 !! using a hybrid sort based on the `'Rust" sort` algorithm found in `slice.rs`
-            integer(${k1}$), intent(inout)           :: array(0:)
-            integer(${k1}$), intent(inout), optional :: work(0:)
+            ${t1}$, intent(inout)           :: array(0:)
+            ${t1}$, intent(inout), optional :: work(0:)
         end subroutine ${k1}$_ord_sort
 
 #:endfor
 
-#:for k1 in REAL_KINDS
-        module subroutine ${k1}$_ord_sort( array, work )
- !! Version: experimental
-!!
-!! `${k1}$_ord_sort( array )` sorts the input `ARRAY` of type `REAL(${k1}$)`
-!! using a hybrid sort based on the `'Rust" sort` algorithm found in `slice.rs`
-            real(${k1}$), intent(inout)           :: array(0:)
-            real(${k1}$), intent(inout), optional :: work(0:)
-        end subroutine ${k1}$_ord_sort
-
-#:endfor
         module subroutine char_ord_sort( array, work )
 !! Version: experimental
 !!
@@ -378,15 +368,6 @@ module stdlib_sorting
             character(len=len(array)), intent(inout), optional :: work(0:)
         end subroutine char_ord_sort
 
-        module subroutine string_ord_sort( array, work )
-!! Version: experimental
-!!
-!! `char_ord_sort( array )` sorts the input `ARRAY` of type `CHARACTER(*)`
-!! using a hybrid sort based on the `'Rust" sort` algorithm found in `slice.rs`
-            type(string_type), intent(inout)           :: array(0:)
-            type(string_type), intent(inout), optional :: work(0:)
-        end subroutine string_ord_sort
-
     end interface ord_sort
 
     interface sort
@@ -395,30 +376,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 IRS_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
@@ -434,17 +401,6 @@ module stdlib_sorting
             character(len=*), intent(inout) :: array(0:)
         end subroutine char_sort
 
-        pure module subroutine string_sort( array )
-!! Version: experimental
-!!
-!! `string_sort( array )` sorts the input `ARRAY` of type `STRING_TYPE`
-!! 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.
-            type(string_type), intent(inout) :: array(0:)
-        end subroutine string_sort
-
     end interface sort
 
     interface sort_index
@@ -458,41 +414,24 @@ module stdlib_sorting
 !! non-decreasing sort, but if the optional argument `REVERSE` is present
 !! with a value of `.TRUE.` the indices correspond to a non-increasing sort.
 
-#:for k1 in INT_KINDS
+#:for k1, t1 in IRS_KINDS_TYPES
         module subroutine ${k1}$_sort_index( array, index, work, iwork, &
             reverse )
 !! Version: experimental
 !!
-!! `${k1}$_sort_index( array )` sorts an input `ARRAY` of type `INTEGER(${k1}$)`
+!! `${k1}$_sort_index( array )` sorts an input `ARRAY` of type `${t1}$`
 !! 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.
-            integer(${k1}$), intent(inout)             :: array(0:)
+            ${t1}$, intent(inout)                      :: array(0:)
             integer(int_size), intent(inout)           :: index(0:)
-            integer(${k1}$), intent(inout), optional   :: work(0:)
+            ${t1}$, intent(inout), optional            :: work(0:)
             integer(int_size), intent(inout), optional :: iwork(0:)
             logical, intent(in), optional              :: reverse
         end subroutine ${k1}$_sort_index
 
 #:endfor
 
-#:for k1 in REAL_KINDS
-        module subroutine ${k1}$_sort_index( array, index, work, iwork, &
-            reverse )
-!! Version: experimental
-!!
-!! `${k1}$_sort_index( array )` sorts an input `ARRAY` of type `REAL(${k1}$)`
-!! 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.
-            real(${k1}$), intent(inout)                :: array(0:)
-            integer(int_size), intent(inout)           :: index(0:)
-            real(${k1}$), intent(inout), optional      :: work(0:)
-            integer(int_size), intent(inout), optional :: iwork(0:)
-            logical, intent(in), optional              :: reverse
-        end subroutine ${k1}$_sort_index
-
-#:endfor
         module subroutine char_sort_index( array, index, work, iwork, &
             reverse )
 !! Version: experimental
@@ -508,21 +447,6 @@ module stdlib_sorting
             logical, intent(in), optional                      :: reverse
         end subroutine char_sort_index
 
-        module subroutine string_sort_index( array, index, work, iwork, &
-            reverse )
-!! Version: experimental
-!!
-!! `string_sort_index( array )` sorts an input `ARRAY` of type `STRING_TYPE`
-!! 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.
-            type(string_type), intent(inout)           :: array(0:)
-            integer(int_size), intent(inout)           :: index(0:)
-            type(string_type), intent(inout), optional :: work(0:)
-            integer(int_size), intent(inout), optional :: iwork(0:)
-            logical, intent(in), optional              :: reverse
-        end subroutine string_sort_index
-
     end interface sort_index