consistent use of k-th smallest as suggested by jvdp1

Author: gareth-nx

doc/specs/stdlib_selection.md

@@ -23,11 +23,11 @@ which implements selection algorithms.
 ## Overview of the module
 
 The module `stdlib_selection` defines two generic subroutines:
-* `select` is used to find the kth-smallest entry of an array. The input
+* `select` is used to find the k-th smallest entry of an array. The input
 array is also modified in-place, and on return will be partially sorted
 such that `all(array(1:k) <= array(k)))`  and `all(array(k) <= array((k+1):size(array)))`.
 The user can optionally specify `left` and `right` indices to constrain the search
-for the kth-smallest value. This can be useful if you have previously called `select`
+for the k-th smallest value. This can be useful if you have previously called `select`
 to find a smaller or larger rank (that will have led to partial sorting of
 `array`, thus implying some constraints on the location).
 
@@ -131,7 +131,7 @@ end of this document shows that is the case.
     end program demo_select
 ```
 
-## `arg_select` - find the kth smallest value in an input array
+## `arg_select` - find the k-th smallest value in an input array
 
 ### Status
 
@@ -156,7 +156,7 @@ Generic subroutine.
 `array` : shall be a rank one array of any of the types:
 `integer(int8)`, `integer(int16)`, `integer(int32)`, `integer(int64)`,
 `real(sp)`, `real(dp)`, `real(qp)`. It is an `intent(in)` argument. On input it is
-the array in which we search for the kth smallest entry.
+the array in which we search for the k-th smallest entry.
 
 `indx`: shall be a rank one array with the same size as `array`, containing all integers
 from `1:size(array)` in any order. It is of any of the types:

src/stdlib_selection.fypp

@@ -55,18 +55,18 @@ contains
           !! quickSelect by Leon Foks, https://github.com/leonfoks/coretran
           !!
           ${arraytype}$, intent(inout) :: a(:)
-              !! Array in which we seek the kth-smallest entry.
+              !! Array in which we seek the k-th smallest entry.
               !! On output it will be partially sorted such that
               !! `all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a)))`.
           ${inttype}$, intent(in) :: k
-              !! We want the kth smallest entry. E.G. `k=1` leads to
+              !! We want the k-th smallest entry. E.G. `k=1` leads to
               !! `kth_smallest=min(a)`, and `k=size(a)` leads to
               !! `kth_smallest=max(a)`
           ${arraytype}$, intent(out) :: kth_smallest
-              !! On output contains the kth-smallest value of `a(:)`
+              !! On output contains the k-th smallest value of `a(:)`
           ${inttype}$, intent(in), optional :: left, right
               !! If we know that:
-              !!    the kth-smallest entry of `a` is in `a(left:right)`
+              !!    the k-th smallest entry of `a` is in `a(left:right)`
               !! and also that:
               !!    `maxval(a(1:(left-1))) <= minval(a(left:right))`
               !! and:
@@ -163,22 +163,22 @@ contains
           !! quickSelect by Leon Foks, https://github.com/leonfoks/coretran
           !!
           ${arraytype}$, intent(in) :: a(:)
-              !! Array in which we seek the kth-smallest entry.
+              !! Array in which we seek the k-th smallest entry.
           ${inttype}$, intent(inout) :: indx(:)
               !! Array of indices into `a(:)`. Must contain each integer
               !! from `1:size(a)` exactly once. On output it will be partially
               !! sorted such that
               !! `all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND.
               !!  all( a(indx(k))  <= a(indx( (k+1):size(a) )) )`.
           ${inttype}$, intent(in) :: k
-              !! We want index of the kth smallest entry. E.G. `k=1` leads to
+              !! We want index of the k-th smallest entry. E.G. `k=1` leads to
               !! `a(kth_smallest) = min(a)`, and `k=size(a)` leads to
               !! `a(kth_smallest) = max(a)`
           ${inttype}$, intent(out) :: kth_smallest
-              !! On output contains the index with the kth-smallest value of `a(:)`
+              !! On output contains the index with the k-th smallest value of `a(:)`
           ${inttype}$, intent(in), optional :: left, right
               !! If we know that:
-              !!  the kth-smallest entry of `a` is in `a(indx(left:right))`
+              !!  the k-th smallest entry of `a` is in `a(indx(left:right))`
               !! and also that:
               !!  `maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right)))`
               !! and: