public interface arg_select
(Specification)
Module Procedures
private subroutine arg_select_1_iint8_int8(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int8), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int8), |
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) )) ). |
| integer(kind=int8), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int8), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int8), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int8), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint8_int16(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int8), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int16), |
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) )) ). |
| integer(kind=int16), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int16), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int16), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int16), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint8_int32(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int8), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int32), |
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) )) ). |
| integer(kind=int32), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int32), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int32), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int32), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint8_int64(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int8), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int64), |
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) )) ). |
| integer(kind=int64), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int64), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int64), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int64), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint16_int8(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int16), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int8), |
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) )) ). |
| integer(kind=int8), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int8), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int8), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int8), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint16_int16(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int16), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int16), |
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) )) ). |
| integer(kind=int16), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int16), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int16), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int16), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint16_int32(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int16), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int32), |
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) )) ). |
| integer(kind=int32), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int32), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int32), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int32), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint16_int64(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int16), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int64), |
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) )) ). |
| integer(kind=int64), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int64), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int64), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int64), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint32_int8(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int32), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int8), |
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) )) ). |
| integer(kind=int8), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int8), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int8), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int8), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint32_int16(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int32), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int16), |
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) )) ). |
| integer(kind=int16), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int16), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int16), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int16), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint32_int32(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int32), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int32), |
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) )) ). |
| integer(kind=int32), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int32), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int32), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int32), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint32_int64(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int32), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int64), |
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) )) ). |
| integer(kind=int64), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int64), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int64), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int64), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint64_int8(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int64), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int8), |
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) )) ). |
| integer(kind=int8), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int8), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int8), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int8), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint64_int16(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int64), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int16), |
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) )) ). |
| integer(kind=int16), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int16), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int16), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int16), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint64_int32(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int64), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int32), |
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) )) ). |
| integer(kind=int32), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int32), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int32), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int32), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_iint64_int64(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| integer(kind=int64), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int64), |
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) )) ). |
| integer(kind=int64), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int64), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int64), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int64), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rsp_int8(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=sp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int8), |
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) )) ). |
| integer(kind=int8), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int8), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int8), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int8), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rsp_int16(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=sp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int16), |
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) )) ). |
| integer(kind=int16), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int16), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int16), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int16), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rsp_int32(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=sp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int32), |
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) )) ). |
| integer(kind=int32), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int32), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int32), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int32), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rsp_int64(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=sp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int64), |
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) )) ). |
| integer(kind=int64), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int64), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int64), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int64), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rdp_int8(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=dp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int8), |
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) )) ). |
| integer(kind=int8), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int8), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int8), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int8), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rdp_int16(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=dp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int16), |
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) )) ). |
| integer(kind=int16), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int16), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int16), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int16), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rdp_int32(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=dp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int32), |
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) )) ). |
| integer(kind=int32), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int32), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int32), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int32), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
private subroutine arg_select_1_rdp_int64(a, indx, k, kth_smallest, left, right)
arg_select - find the index of the k-th smallest entry in a(:)
Read more…
Arguments
| Type | Intent | Optional | Attributes | | Name | |
|---|
| real(kind=dp), |
intent(in) |
| | :: |
a(:) | Array in which we seek the k-th smallest entry. |
| integer(kind=int64), |
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) )) ). |
| integer(kind=int64), |
intent(in) |
| | :: |
k | 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) |
| integer(kind=int64), |
intent(out) |
| | :: |
kth_smallest | On output contains the index with the k-th smallest value of a(:) |
| integer(kind=int64), |
intent(in), |
optional | | :: |
left | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
| integer(kind=int64), |
intent(in), |
optional | | :: |
right | If we know that:
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:
maxval(a(indx(left:right))) <= minval(a(indx((right+1):size(a))))
then one or both bounds can be specified to reduce the search
time. These constraints are available if we have previously
called the subroutine with a different k (due to the way that
indx(:) becomes partially sorted, see documentation for indx(:)). |
