stdlib_selection 模块

快速查找数组中第 k 小的值，或第 k 小值的索引。(规范)


使用


接口

public interface arg_select

(规范)

  • private subroutine arg_select_1_iint8_int8(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int8), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int8), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int8), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint8_int16(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int16), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int16), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int16), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint8_int32(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int32), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int32), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int32), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint8_int64(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int64), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int64), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int64), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint16_int8(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int8), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int8), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int8), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint16_int16(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int16), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int16), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int16), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint16_int32(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int32), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int32), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int32), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint16_int64(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int64), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int64), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int64), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint32_int8(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int8), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int8), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int8), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint32_int16(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int16), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int16), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int16), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint32_int32(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int32), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int32), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int32), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint32_int64(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int64), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int64), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int64), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint64_int8(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int8), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int8), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int8), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint64_int16(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int16), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int16), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int16), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint64_int32(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int32), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int32), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int32), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_iint64_int64(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int64), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int64), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int64), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_rsp_int8(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int8), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int8), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int8), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_rsp_int16(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int16), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int16), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int16), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_rsp_int32(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int32), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int32), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int32), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_rsp_int64(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int64), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int64), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int64), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_rdp_int8(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int8), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int8), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    integer(kind=int8), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    integer(kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    integer(kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • private subroutine arg_select_1_rdp_int16(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    integer(kind=int16), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    integer(kind=int16), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    整数 (kind=int16), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • 私有子程序 arg_select_1_rdp_int32(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=dp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    整数 (kind=int32), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    整数 (kind=int32), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

  • 私有子程序 arg_select_1_rdp_int64(a, indx, k, kth_smallest, left, right)

    arg_select - 在 a(:) 中查找第 k 小的元素的索引

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=dp), intent(in) :: a(:)

    我们要查找第 k 小元素的数组。
    整数 (kind=int64), intent(inout) :: indx(:)

    a(:) 的索引数组。必须包含从 1:size(a) 的每个整数恰好一次。在输出时，它将被部分排序，使得 all( a(indx(1:(k-1)))) <= a(indx(k)) ) .AND. all( a(indx(k)) <= a(indx( (k+1):size(a) )) )。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小元素的索引。例如，k=1 导致 a(kth_smallest) = min(a)，而 k=size(a) 导致 a(kth_smallest) = max(a)
    整数 (kind=int64), intent(out) :: kth_smallest

    在输出时包含 a(:) 的第 k 小值的索引
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小元素在 a(indx(left:right)) 中，并且：maxval(a(indx(1:(left-1)))) <= minval(a(indx(left:right))) 以及：maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))，那么可以指定一个或两个边界来减少搜索时间。如果我们之前使用不同的 k 调用了子例程，则这些约束可用（由于 indx(:) 的部分排序方式，请参阅 indx(:) 的文档）。

公共接口 select

(规范)

  • 私有子程序 select_1_iint8_int8(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int8), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int8), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int8), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint8_int16(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int8), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int16), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int8), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint8_int32(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int8), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int8), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint8_int64(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int8), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int8), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint16_int8(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int16), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int8), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int16), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint16_int16(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int16), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int16), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int16), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint16_int32(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int16), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int16), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint16_int64(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int16), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int16), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint32_int8(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int32), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int8), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int32), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint32_int16(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int32), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int16), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int32), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint32_int32(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int32), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int32), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint32_int64(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int32), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int32), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint64_int8(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int64), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int8), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int64), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint64_int16(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int64), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int16), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int64), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint64_int32(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int64), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int64), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_iint64_int64(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    整数 (kind=int64), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    整数 (kind=int64), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rsp_int8(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=sp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int8), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=sp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rsp_int16(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=sp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int16), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=sp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rsp_int32(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=sp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=sp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rsp_int64(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=sp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=sp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rdp_int8(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=dp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int8), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=dp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int8), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int8), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rdp_int16(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=dp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int16), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=dp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int16), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int16), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rdp_int32(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=dp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int32), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=dp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int32), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int32), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。

  • 私有子程序 select_1_rdp_int64(a, k, kth_smallest, left, right)

    select - 选择 a(:) 中第 k 小的元素。

    部分源自 Leon Foks 的“Coretran”快速选择实现，https://github.com/leonfoks/coretran

    参数

    类型 意图可选 属性 名称
    实数 (kind=dp), intent(inout) :: a(:)

    我们要在其中查找第 k 小元素的数组。输出时，它将被部分排序，使得 all(a(1:(k-1)) <= a(k)) .and. all(a(k) <= a((k+1):size(a))) 为真。
    整数 (kind=int64), intent(in) :: k

    我们想要第 k 小的元素。例如，k=1 导致 kth_smallest=min(a)，而 k=size(a) 导致 kth_smallest=max(a)
    实数 (kind=dp), intent(out) :: kth_smallest

    输出时包含 a(:) 的第 k 小的值
    整数 (kind=int64), intent(in), optional :: left

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。
    整数 (kind=int64), intent(in), optional :: right

    如果我们知道：a 的第 k 小的元素在 a(left:right) 中，并且：maxval(a(1:(left-1))) <= minval(a(left:right)) 以及：maxval(a(left:right))) <= minval(a((right+1):size(a)))，那么可以指定一个或两个边界来缩小搜索范围。如果我们之前使用不同的 k 调用了子程序，则这些约束条件可用（因为 a(:) 的部分排序方式，请参阅 a(:) 的文档）。