pm_arraySort Module Reference

This module contains procedures and generic interfaces for various sorting tasks.
More...

Data Types
type	bubble_type
interface	getSorted
	Generate and return the sorted elements of the input scalar string or contiguous vector in ascending order, or the sorted indices of the input scalar string or contiguous array of rank 1 in ascending order or in the user-specified order. More...
type	heap_type
type	heapi_type
type	heapr_type
type	insertion_type
type	insertionb_type
type	insertionl_type
interface	isAscending
	Generate and return .true. if the input array is sorted in ascending order (with the possibility of elements being equal), otherwise, generate and return .false.. More...
interface	isAscendingAll
	Generate and return .true. if the input array is sorted in strictly all ascending order (without equal elements), otherwise, generate and return .false.. More...
interface	isDescending
	Generate and return .true. if the input array is sorted in descending order (with the possibility of elements being equal), otherwise, generate and return .false.. More...
interface	isDescendingAll
	Generate and return .true. if the input array is sorted in strictly all descending order (without equal elements), otherwise, generate and return .false.. More...
type	isort_type
interface	isSorted
	Return .true. if the input array is sorted, either ascending or descending, or all equal. More...
type	merger_type
type	qsort_type
type	qsorti_type
type	qsortr_type
type	qsortrdp_type
type	selection_type
interface	setSorted
	Sort the input scalar string or contiguous vector in ascending order, or return the sorted indices of the input scalar string or contiguous array of rank 1 in ascending order or in the user-specified order. More...
type	shell_type
type	sort_type

Variables
character(*, SK), parameter	MODULE_NAME = "@pm_arraySort"
type(isort_type), parameter	isort = isort_type()
type(qsorti_type), parameter	qsorti = qsorti_type()
type(qsortr_type), parameter	qsortr = qsortr_type()
type(qsortrdp_type), parameter	qsortrdp = qsortrdp_type()
type(bubble_type), parameter	bubble = bubble_type()
type(heapi_type), parameter	heapi = heapi_type()
type(heapr_type), parameter	heapr = heapr_type()
type(insertionl_type), parameter	insertionl = insertionl_type()
type(insertionb_type), parameter	insertionb = insertionb_type()
type(merger_type), parameter	merger = merger_type()
type(selection_type), parameter	selection = selection_type()
type(shell_type), parameter	shell = shell_type()

Detailed Description

This module contains procedures and generic interfaces for various sorting tasks.

Specifically, the generic interfaces of this module fall into three categories:

1. Testing whether an array of intrinsic type and kind is in
   1. ascending,
   2. descending,
   3. sorted (i.e., either ascending or descending),
   4. all ascending (i.e., strictly ascending with no duplicates),
   5. all descending (i.e., strictly descending with no duplicates),
   6. user-specified,
   order.
   
2. Sorting the indices of an array of intrinsic type and kind in ascending order.
   
3. Sorting the elements of an array of intrinsic type and kind in ascending order.
   
4. Generating sorted indices of an array of intrinsic type and kind in ascending order.
   
5. Generating sorted elements of an array of intrinsic type and kind in ascending order.
   

There are currently twelve different sorting algorithms implemented in this module in addition to index sorting and sort checking algorithms.

Note

Recommended routines for sorting arrays:
The procedures under the generic interface setSorted with default

Benchmarks:

Benchmark :: sorting ⛓

The following is program to test the performance of the different sorting algorithms in this module.

! Test the performance of different sorting algorithms in pm_arraySort.
program benchmark
 
    use pm_kind, only: IK, LK, RK, SK
    use pm_bench, only: bench_type
 
    implicit none
 
    logical(LK)                         :: issorted
    integer(IK)                         :: i
    integer(IK)                         :: iarr
    integer(IK)                         :: fileUnitRandom
    integer(IK)                         :: fileUnitSorted
    integer(IK) , parameter             :: NARR = 12_IK
    integer(IK) , parameter             :: NBENCH = 11_IK
    integer(IK)                         :: arraySize(NARR)
    real(RK)  , allocatable             :: array(:)
    type(bench_type)                    :: bench(2,NBENCH)
 
    bench(1:2, 1) = bench_type(name = SK_"setSortedQsorti       ", exec = setSortedQsorti       , overhead = setOverhead)
    bench(1:2, 2) = bench_type(name = SK_"setSortedQsortr       ", exec = setSortedQsortr       , overhead = setOverhead)
    bench(1:2, 4) = bench_type(name = SK_"setSortedQsortrdp     ", exec = setSortedQsortrdp     , overhead = setOverhead)
    bench(1:2, 3) = bench_type(name = SK_"setSortedBubble       ", exec = setSortedBubble       , overhead = setOverhead)
    bench(1:2, 5) = bench_type(name = SK_"setSortedHeapi        ", exec = setSortedHeapi        , overhead = setOverhead)
    bench(1:2, 6) = bench_type(name = SK_"setSortedHeapr        ", exec = setSortedHeapr        , overhead = setOverhead)
    bench(1:2, 7) = bench_type(name = SK_"setSortedInsertionl   ", exec = setSortedInsertionl   , overhead = setOverhead)
    bench(1:2, 8) = bench_type(name = SK_"setSortedInsertionb   ", exec = setSortedInsertionb   , overhead = setOverhead)
    bench(1:2, 9) = bench_type(name = SK_"setSortedMerge        ", exec = setSortedMerge        , overhead = setOverhead)
    bench(1:2,10) = bench_type(name = SK_"setSortedSelection    ", exec = setSortedSelection    , overhead = setOverhead)
    bench(1:2,11) = bench_type(name = SK_"setSortedShell        ", exec = setSortedShell        , overhead = setOverhead)
 
    arraySize = [( 2_IK**iarr, iarr = 3_IK, NARR + 2_IK )]
 
    write(*,"(*(g0,:,' '))")
    write(*,"(*(g0,:,' '))") "setSorted() vs. others."
    write(*,"(*(g0,:,' '))")
 
    open(newunit = fileUnitRandom, file = "main.random.out", status = "replace")
    open(newunit = fileUnitSorted, file = "main.sorted.out", status = "replace")
 
        write(fileUnitRandom       ,"(*(g0,:,','))") "arraySize", (bench(1,i)%name, i = 1, NBENCH)
        write(fileUnitSorted,"(*(g0,:,','))") "arraySize", (bench(2,i)%name, i = 1, NBENCH)
 
        loopOverArraySize: do iarr = 1, NARR
 
            allocate(array(arraySize(iarr)))
            write(*,"(*(g0,:,' '))") "Benchmarking sorting algorithms with array size", arraySize(iarr)
 
            ! Time sorting algorithms against the default setSorted() procedures.
 
            issorted = .false._LK
            do i = 1, NBENCH
                bench(1,i)%timing = bench(1,i)%getTiming()
            end do
            write(fileUnitRandom,"(*(g0,:,','))") arraySize(iarr), (bench(1,i)%timing%mean, i = 1, NBENCH)
 
            ! Time sorting algorithms with sorted input arrays against unordered input arrays.
 
            issorted = .true._LK
            do i = 1, NBENCH
                bench(2,i)%timing = bench(2,i)%getTiming()
            end do
            write(fileUnitSorted,"(*(g0,:,','))") arraySize(iarr), (bench(2,i)%timing%mean, i = 1, NBENCH)
 
            deallocate(array)
 
        end do loopOverArraySize
        write(*,"(*(g0,:,' '))")
 
    close(fileUnitSorted)
    close(fileUnitRandom)
 
contains
 
    ! sorting procedure wrappers.
 
    subroutine setOverhead()
        call setArray()
    end subroutine
 
    subroutine setArray()
        use pm_arraySpace, only: getLinSpace
        if (issorted) then
            array(:) = getLinSpace(0._RK, 1._RK, count = size(array, kind = IK))
        else
            call random_number(array)
        end if
    end subroutine
 
    subroutine setSortedQsorti()
        call setArray()
        block; use pm_arraySort, only: setSorted, qsorti; call setSorted(array, qsorti); end block
    end subroutine
 
    subroutine setSortedQsortr()
        call setArray()
        block; use pm_arraySort, only: setSorted, qsortr; call setSorted(array, qsortr); end block
    end subroutine
 
    subroutine setSortedQsortrdp()
        call setArray()
        block; use pm_arraySort, only: setSorted, qsortrdp; call setSorted(array, qsortrdp); end block
    end subroutine
 
    subroutine setSortedBubble()
        call setArray()
        block; use pm_arraySort, only: setSorted, bubble; call setSorted(array, bubble); end block
    end subroutine
 
    subroutine setSortedHeapi()
        call setArray()
        block; use pm_arraySort, only: setSorted, heapi; call setSorted(array, heapi); end block
    end subroutine
 
    subroutine setSortedHeapr()
        call setArray()
        block; use pm_arraySort, only: setSorted, heapr; call setSorted(array, heapr); end block
    end subroutine
 
    subroutine setSortedInsertionl()
        call setArray()
        block; use pm_arraySort, only: setSorted, insertionl; call setSorted(array, insertionl); end block
    end subroutine
 
    subroutine setSortedInsertionb()
        call setArray()
        block; use pm_arraySort, only: setSorted, insertionb; call setSorted(array, insertionb); end block
    end subroutine
 
    subroutine setSortedMerge()
        call setArray()
        block; use pm_arraySort, only: setSorted, merger; call setSorted(array, merger); end block
    end subroutine
 
    subroutine setSortedSelection()
        call setArray()
        block; use pm_arraySort, only: setSorted, selection; call setSorted(array, selection); end block
    end subroutine
 
    subroutine setSortedShell()
        call setArray()
        block; use pm_arraySort, only: setSorted, shell; call setSorted(array, shell); end block
    end subroutine
 
end program benchmark

Example Unix compile command via Intel ifort compiler ⛓

#!/usr/bin/env sh
rm main.exe
ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓

del main.exe
set PATH=..\..\..\lib;%PATH%
ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓

#!/usr/bin/env sh
rm main.exe
gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Postprocessing of the benchmark output ⛓

#!/usr/bin/env python
 
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
fontsize = 15
 
colnames =  [ "setSortedQsorti"
            , "setSortedQsortr"
            , "setSortedQsortrdp"
            , "setSortedBubble"
            , "setSortedHeapi"
            , "setSortedInsertionl"
            , "setSortedInsertionb"
            , "setSortedMerge"
            , "setSortedSelection"
            , "setSortedShell"
            ]
 
dtypes = ["random", "sorted"]
 
 
 
df = {}
 
for dtype in dtypes:
 
    df[dtype] = pd.read_csv("main.{}.out".format(dtype))
    colnames = list(df[dtype].columns.values[1:])
 
    ax = plt.figure(figsize = 1.25 * np.array([9.4,4.8]), dpi = 200)
    ax = plt.subplot()
 
    for colname in colnames:
        plt.plot( df[dtype].values[:, 0]
                , df[dtype][colname].values / df[dtype]["setSortedQsorti"].values
                , linewidth = 2
                )
 
    plt.xticks(fontsize = fontsize)
    plt.yticks(fontsize = fontsize)
    ax.set_xlabel("Array Size (# elements)", fontsize = fontsize)
    ax.set_ylabel("Time normalized to qsorti timing", fontsize = fontsize)
    ax.set_title("Benchmarking of sorting algorithms compared to qsorti.\nInput data is " + r"$\mathrm{\bf{" + dtype + "}}$. Lower is better.", fontsize = fontsize)
    ax.set_xscale("log")
    ax.set_yscale("log")
    plt.minorticks_on()
    plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
    ax.tick_params(axis = "y", which = "minor")
    ax.tick_params(axis = "x", which = "minor")
    ax.legend   ( colnames
                , loc='center left'
                , bbox_to_anchor=(1, 0.5)
                , fontsize = fontsize
                )
 
    plt.tight_layout()
    plt.savefig("benchmark.sorting.{}.png".format(dtype))
 
 
 
ax = plt.figure(figsize = 1.25 * np.array([9.4,4.8]), dpi = 200)
ax = plt.subplot()
 
for colname in colnames:
    plt.plot( df["random"].values[:, 0]
            , df["sorted"][colname].values / df["random"][colname].values
            , linewidth = 2
            )
 
plt.xticks(fontsize = fontsize)
plt.yticks(fontsize = fontsize)
ax.set_xlabel("Array Size (# elements)", fontsize = fontsize)
ax.set_ylabel("Sorting Time Ratio ( Sorted / Random Input Array )", fontsize = fontsize)
ax.set_title("Sorted / Random input-arrays sorting-time ratio. Lower is better.", fontsize = fontsize)
ax.set_xscale("log")
ax.set_yscale("log")
plt.minorticks_on()
plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
ax.tick_params(axis = "y", which = "minor")
ax.tick_params(axis = "x", which = "minor")
ax.legend   ( colnames
            , loc='center left'
            , bbox_to_anchor=(1, 0.5)
            , fontsize = fontsize
            )
 
plt.tight_layout()
plt.savefig("benchmark.sorting.random.sorted.ratio.png")

Visualization of the benchmark output ⛓

Benchmark :: sorting vs. indexing ⛓

The following program generates a performance comparison of the setSorted algorithm for various sorting methods.

program benchmark
 
    use pm_kind, only: IK, LK, RKG => RK
    use pm_arrayResize, only: setResized
    use pm_distUnif, only: getUnifRand
    use pm_arraySort, only: setSorted
    use pm_bench, only: bench_type
 
    implicit none
 
    integer(IK)                         :: i,iarr
    integer(IK)                         :: fileUnitRandom
    integer(IK)                         :: fileUnitSorted
    integer(IK) , parameter             :: NARR = 12_IK
    integer(IK) , parameter             :: NBENCH = 3_IK
    integer(IK)                         :: arraySize(NARR)
    real(RKG)   , allocatable           :: array(:)
    integer(IK) , allocatable           :: index(:)
    logical(LK)                         :: issorted
    type(bench_type)                    :: bench(2,NBENCH)
 
    bench(:,1) = bench_type("setSortedArray", setSortedArray, setOverhead)
    bench(:,2) = bench_type("setSortedIndex", setSortedIndex, setOverhead)
    bench(:,3) = bench_type("setSortedindexWithSorting", setSortedindexWithSorting, setOverhead)
 
    arraySize = [( 2_IK**i, i = 3_IK, NARR + 2_IK )]
 
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    ! Time the setSortedArray() against setSortedIndex() for different array sizes.
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
    write(*,"(*(g0,:,' '))")
    write(*,"(*(g0,:,' '))") "setSortedArray() vs. setSortedIndex()."
    write(*,"(*(g0,:,' '))")
 
    open(newunit = fileUnitRandom, file = "main.random.out", status = "replace")
    open(newunit = fileUnitSorted, file = "main.sorted.out", status = "replace")
    write(fileUnitRandom,"(*(g0,:,','))") "arraySize", (bench(1,i)%name, i = 1, NBENCH)
    write(fileUnitSorted,"(*(g0,:,','))") "arraySize", (bench(2,i)%name, i = 1, NBENCH)
 
    loopOverarraySize: do iarr = 1, NARR
 
        write(*,"(*(g0,:,' '))") "Benchmarking with array size", arraySize(iarr)
 
        array = getUnifRand(1._RKG, 2._RKG, arraySize(iarr))
        call setResized(index, arraySize(iarr))
 
        issorted = .false._LK
        do i = 1, NBENCH
            bench(1,i)%timing = bench(1,i)%getTiming()
        end do
 
        write(fileUnitRandom,"(*(g0,:,','))") arraySize(iarr), (bench(1,i)%timing%mean, i = 1, NBENCH)
 
        issorted = .true._LK
        do i = 1, NBENCH
            bench(2,i)%timing = bench(2,i)%getTiming()
        end do
 
        write(fileUnitSorted,"(*(g0,:,','))") arraySize(iarr), (bench(2,i)%timing%mean, i = 1, NBENCH)
 
    end do loopOverarraySize
 
    close(fileUnitRandom)
    close(fileUnitSorted)
 
contains
 
    subroutine setarray()
        use pm_arraySpace, only: getLinSpace
        if (issorted) then
            array(:) = getLinSpace(0._RKG, 1._RKG, count = size(array, kind = IK))
        else
            call random_number(array)
        end if
    end subroutine
 
    subroutine setOverhead()
        call setarray()
    end subroutine
 
    subroutine setSortedArray()
        call setSorted(array)
    end subroutine
 
    subroutine setSortedIndex()
        call setSorted(array, index)
    end subroutine
 
    subroutine setSortedindexWithSorting()
        call setSorted(array, index)
        array(:) = array(index)
    end subroutine
 
end program benchmark

Example Unix compile command via Intel ifort compiler ⛓

#!/usr/bin/env sh
rm main.exe
ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓

del main.exe
set PATH=..\..\..\lib;%PATH%
ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓

#!/usr/bin/env sh
rm main.exe
gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Postprocessing of the benchmark output ⛓

#!/usr/bin/env python
 
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
fontsize = 15
 
 
 
dtypes = ["random", "sorted"]
 
for dtype in dtypes:
 
    df = pd.read_csv("main.{}.out".format(dtype))
 
    
 
    ax = plt.figure(figsize = 1.25 * np.array([9.4,4.8]), dpi = 200)
    ax = plt.subplot()
 
    for colname in df.columns[1:]:
        plt.plot( df.values[:, 0]
                , df[colname].values
                , linewidth = 2
                )
 
    plt.xticks(fontsize = fontsize)
    plt.yticks(fontsize = fontsize)
    ax.set_xlabel("Array Size (# elements)", fontsize = fontsize)
    ax.set_ylabel("Time [ seconds ]", fontsize = fontsize)
    ax.set_title("timing of setSortedArray() vs. setSortedIndex(). Input data is {}.\n Lower is better.".format(dtype), fontsize = fontsize)
    ax.set_xscale("log")
    ax.set_yscale("log")
    plt.minorticks_on()
    plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
    ax.tick_params(axis = "y", which = "minor")
    ax.tick_params(axis = "x", which = "minor")
    ax.legend   ( df.columns[1:]
               #, loc='center left'
               #, bbox_to_anchor=(1, 0.5)
                , fontsize = fontsize
                )
 
    plt.tight_layout()
    plt.savefig("benchmark.sorting_vs_indexing.{}.png".format(dtype))
 
    
 
    ax = plt.figure(figsize = 1.25 * np.array([9.4,4.8]), dpi = 200)
    ax = plt.subplot()
 
    start = 0
 
    plt.plot( df.values[:, 0]
            , np.ones(len(df.values[:, 0]))
            , linestyle = "--"
            , linewidth = 2
           #, color = "black"
            )
    for colname in df.columns[2:]:
        plt.plot( df.values[start:,0]
                , df[colname].values[start:] / df["setSortedArray"].values[start:]
                , linewidth = 2
                )
 
    plt.xticks(fontsize = fontsize)
    plt.yticks(fontsize = fontsize)
    ax.set_xlabel("Array Size (# elements)", fontsize = fontsize)
    ax.set_ylabel("Time Ratio ( setSortedIndex() / setSortedArray() )", fontsize = fontsize)
    ax.set_title("Ratio of timing of setSortedIndex() to setSortedArray(). Input data is {}.".format(dtype), fontsize = fontsize)
    ax.set_xscale("log")
    #ax.set_yscale("log")
    plt.minorticks_on()
    plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
    ax.tick_params(axis = "y", which = "minor")
    ax.tick_params(axis = "x", which = "minor")
    ax.legend   ( ["setSortedArray"] + list(df.columns[2:])
               #, bbox_to_anchor=(1, 0.5)
               #, loc='center left'
                , fontsize = fontsize
                )
 
    plt.tight_layout()
    plt.savefig("benchmark.sorting_vs_indexing.{}.ratio.png".format(dtype))
 
 

Visualization of the benchmark output ⛓

Todo:

Very Low Priority: An equivalent functional versions of setSorted and setSorted could be added along with the relevant benchmarks.

Remarks

The sorting routines of this module are inspired by (although substantially different from),

• the works of Dr. Michael Rutter and,
• the Numerical Recipes in Fortran by Press et al., 1992.

Final Remarks ⛓

---

If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
   
2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.
   

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Copyright

Computational Data Science Lab

Author:

Amir Shahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Variable Documentation

bubble

type(bubble_type), parameter pm_arraySort::bubble = bubble_type()

Definition at line 134 of file pm_arraySort.F90.

heapi

type(heapi_type), parameter pm_arraySort::heapi = heapi_type()

Definition at line 138 of file pm_arraySort.F90.

heapr

type(heapr_type), parameter pm_arraySort::heapr = heapr_type()

Definition at line 142 of file pm_arraySort.F90.

insertionb

type(insertionb_type), parameter pm_arraySort::insertionb = insertionb_type()

Definition at line 150 of file pm_arraySort.F90.

insertionl

type(insertionl_type), parameter pm_arraySort::insertionl = insertionl_type()

Definition at line 146 of file pm_arraySort.F90.

isort

type(isort_type), parameter pm_arraySort::isort = isort_type()

Definition at line 117 of file pm_arraySort.F90.

merger

type(merger_type), parameter pm_arraySort::merger = merger_type()

Definition at line 154 of file pm_arraySort.F90.

MODULE_NAME

character(*,SK), parameter pm_arraySort::MODULE_NAME = "@pm_arraySort"

Definition at line 95 of file pm_arraySort.F90.

qsorti

type(qsorti_type), parameter pm_arraySort::qsorti = qsorti_type()

Definition at line 122 of file pm_arraySort.F90.

qsortr

type(qsortr_type), parameter pm_arraySort::qsortr = qsortr_type()

Definition at line 126 of file pm_arraySort.F90.

qsortrdp

type(qsortrdp_type), parameter pm_arraySort::qsortrdp = qsortrdp_type()

Definition at line 130 of file pm_arraySort.F90.

selection

type(selection_type), parameter pm_arraySort::selection = selection_type()

Definition at line 158 of file pm_arraySort.F90.

shell

type(shell_type), parameter pm_arraySort::shell = shell_type()

Definition at line 162 of file pm_arraySort.F90.