sort_adjoint Interface
-
- experimental
- 422 statements
- Source File
public interface sort_adjoint
The generic subroutine interface implementing the SORT_ADJ algorithm,
based on the "Rust" sort algorithm found in slice.rs
https://github.com/rust-lang/rust/blob/90eb44a5897c39e3dff9c7e48e3973671dcd9496/src/liballoc/slice.rs#L2159
but modified to return an array of indices that would provide a stable
sort of the rank one ARRAY input.
(Specification)
The indices by default correspond to a
non-decreasing sort, but if the optional argument REVERSE is present
with a value of .TRUE. the indices correspond to a non-increasing sort.
Subroutines
private module subroutine bitset_64_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_64_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_64), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_64), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_64_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_64_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_64_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_64_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_64_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_64_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_64_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_64_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_64_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_64_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_64), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_64), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_large_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_large_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_large)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_large), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_large), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_large_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_large_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_large)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_large), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_large), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_large_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_large_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_large)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_large), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_large), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_large_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_large_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_large)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_large), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_large), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_large_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_large_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_large)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_large), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_large), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine bitset_large_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
bitset_large_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(bitset_large)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(bitset_large), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| type(bitset_large), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine char_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
char_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type character(len=*)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| character(len=len), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine char_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
char_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type character(len=*)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| character(len=len), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine char_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
char_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type character(len=*)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| character(len=len), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine char_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
char_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type character(len=*)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| character(len=len), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine char_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
char_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type character(len=*)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| character(len=len), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine char_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
char_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type character(len=*)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character(len=*), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| character(len=len), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine dp_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
dp_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(dp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=dp), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine dp_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
dp_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(dp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=dp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine dp_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
dp_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(dp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=dp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine dp_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
dp_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(dp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=dp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine dp_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
dp_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(dp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=dp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine dp_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
dp_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(dp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=dp), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int16_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int16_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int16)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int16), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int16), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int16_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int16_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int16)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int16), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int16), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int16_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int16_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int16)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int16), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int16), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int16_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int16_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int16)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int16), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int16), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int16_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int16_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int16)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int16), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int16), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int16_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int16_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int16)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int16), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int16), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int32_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int32_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int32)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int32), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int32), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int32_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int32_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int32)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int32), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int32), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int32_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int32_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int32)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int32), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int32), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int32_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int32_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int32)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int32), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int32), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int32_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int32_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int32)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int32), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int32), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int32_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int32_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int32)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int32), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int32), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int64_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int64_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int64), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int64), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int64_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int64_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int64_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int64_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int64_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int64_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int64_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int64_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int64), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int64), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int64_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int64_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int64)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int64), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int64), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int8_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int8_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int8)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int8), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int8), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int8_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int8_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int8)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int8), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int8), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int8_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int8_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int8)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int8), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int8), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int8_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int8_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int8)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int8), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int8), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int8_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int8_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int8)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int8), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int8), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine int8_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
int8_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type integer(int8)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=int8), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| integer(kind=int8), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine sp_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
sp_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(sp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=sp), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine sp_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
sp_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(sp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=sp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine sp_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
sp_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(sp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=sp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine sp_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
sp_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(sp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=sp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine sp_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
sp_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(sp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=sp), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine sp_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
sp_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type real(sp)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| real(kind=sp), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine string_type_dp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
string_type_dp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(string_type)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(string_type), | intent(inout) | :: | array(0:) | |||
| real(kind=dp), | intent(inout) | :: | adjoint_array(0:) | |||
| type(string_type), | intent(out), | optional | :: | work(0:) | ||
| real(kind=dp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine string_type_int16_sort_adjoint(array, adjoint_array, work, iwork, reverse)
string_type_int16_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(string_type)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(string_type), | intent(inout) | :: | array(0:) | |||
| integer(kind=int16), | intent(inout) | :: | adjoint_array(0:) | |||
| type(string_type), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int16), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine string_type_int32_sort_adjoint(array, adjoint_array, work, iwork, reverse)
string_type_int32_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(string_type)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(string_type), | intent(inout) | :: | array(0:) | |||
| integer(kind=int32), | intent(inout) | :: | adjoint_array(0:) | |||
| type(string_type), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int32), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine string_type_int64_sort_adjoint(array, adjoint_array, work, iwork, reverse)
string_type_int64_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(string_type)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(string_type), | intent(inout) | :: | array(0:) | |||
| integer(kind=int64), | intent(inout) | :: | adjoint_array(0:) | |||
| type(string_type), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int64), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine string_type_int8_sort_adjoint(array, adjoint_array, work, iwork, reverse)
string_type_int8_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(string_type)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(string_type), | intent(inout) | :: | array(0:) | |||
| integer(kind=int8), | intent(inout) | :: | adjoint_array(0:) | |||
| type(string_type), | intent(out), | optional | :: | work(0:) | ||
| integer(kind=int8), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |
private module subroutine string_type_sp_sort_adjoint(array, adjoint_array, work, iwork, reverse)
string_type_sp_sort_adjoint( array, adjoint_array[, work, iwork, reverse] ) sorts
an input ARRAY of type type(string_type)
using a hybrid sort based on the "Rust" sort algorithm found in slice.rs
and returns the sorted ARRAY and an array INDEX of indices in the
order that would sort the input ARRAY in the desired direction.
Arguments
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(string_type), | intent(inout) | :: | array(0:) | |||
| real(kind=sp), | intent(inout) | :: | adjoint_array(0:) | |||
| type(string_type), | intent(out), | optional | :: | work(0:) | ||
| real(kind=sp), | intent(out), | optional | :: | iwork(0:) | ||
| logical, | intent(in), | optional | :: | reverse |