Aardvark.Base


SortingExtensions

Static members

Static memberDescription
CreatePermutationHeapSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: (a:int []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: (a:int64 []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: (a:float32 []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: (a:float []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: a:List<int> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: a:List<int64> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: a:List<float32> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: a:List<float> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:int []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:int64 []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:float32 []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:float []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: (a:int []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: (a:int64 []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: (a:float32 []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: (a:float []) -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: a:List<int> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: a:List<int64> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: a:List<float32> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: a:List<float> -> int []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:int []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:int64 []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:float32 []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:float []) -> int64 []

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationHeapSortLong(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int64 []
Type parameters: 'T

The PermutationHeapSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

CreatePermutationQuickMedian(...)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedian(...)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:int [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:int64 [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:float32 [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:float [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<int> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<int64> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<float32> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<float> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:'T [] * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,int> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,float> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<'T> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:int [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:int64 [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:float32 [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:float [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:'T [] * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:int [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:int64 [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:float32 [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:float [] * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<int> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<int64> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<float32> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<float> * med:int) -> int []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:'T [] * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,int> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,float> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<'T> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * med:int) -> int []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:int [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:int64 [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:float32 [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:float [] * med:int64) -> int64 []

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:'T [] * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickMedianLong(...)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * med:int64) -> int64 []
Type parameters: 'T

The CreatePermutationQuickMedian algorithm returns an array of element indices p that reference the elements in the data array in a partially sorted manner, such that p[med] is placed at the correct position, and correctly partitions the array into larger and smaller elements.

CreatePermutationQuickSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: (a:int []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: (a:int64 []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: (a:float32 []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: (a:float []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: a:List<int> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: a:List<int64> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: a:List<float32> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: a:List<float> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:int []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:int64 []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:float32 []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:float []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: (a:int []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: (a:int64 []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: (a:float32 []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: (a:float []) -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: a:List<int> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: a:List<int64> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: a:List<float32> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: a:List<float> -> int []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:int []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:int64 []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:float32 []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:float []) -> int64 []

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationQuickSortLong(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int64 []
Type parameters: 'T

The CreatePermutationQuickSort algorithm returns an array of element indices p that reference the elements in the data array in sorted a manner.

CreatePermutationSmoothSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: (a:int []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: (a:int64 []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: (a:float32 []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: (a:float []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: a:List<int> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: a:List<int64> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: a:List<float32> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: a:List<float> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:int []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:int64 []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:float32 []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:float []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: (a:int []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: (a:int64 []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: (a:float32 []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: (a:float []) -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: a:List<int> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: a:List<int64> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: a:List<float32> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: a:List<float> -> int []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:int []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:int64 []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:float32 []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:float []) -> int64 []

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationSmoothSortLong(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int64 []
Type parameters: 'T

The PermutationSmoothSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion.

CreatePermutationTimSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: (a:int []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: (a:int64 []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: (a:float32 []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: (a:float []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: a:List<int> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: a:List<int64> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: a:List<float32> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: a:List<float> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(a)
Signature: (a:int []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(a)
Signature: (a:int64 []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(a)
Signature: (a:float32 []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(a)
Signature: (a:float []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(a)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortAscendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: (a:int []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: (a:int64 []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: (a:float32 []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: (a:float []) -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: a:List<int> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: a:List<int64> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: a:List<float32> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: a:List<float> -> int []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: (a:'T []) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(a)
Signature: a:List<'T> -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float>) -> int []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:int []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:int64 []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:float32 []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:float []) -> int64 []

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:'T []) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,int64>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float32>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortDescendingLong(...)
Signature: (a:'T [] * selector:Func<'T,float>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

CreatePermutationTimSortLong(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> int64 []
Type parameters: 'T

The PermutationTimSort algorithm returns an array of element indices that enumerate the array elements in sorted fashion. The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

HeapSort(a, cmp, begin, end)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSort(a, cmp, begin, end)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSort(a, aget, aset, cmp, begin, end)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSort(a, count, aget, aset, cmp)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:int [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: (a:int []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:int64 [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: (a:int64 []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:float32 [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: (a:float32 []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:float [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: (a:float []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:List<int> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: a:List<int> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:List<int64> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: a:List<int64> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:List<float32> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: a:List<float32> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:List<float> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: a:List<float> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:'T [] * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, begin, end)
Signature: (a:List<'T> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(a, count, aget, aset)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:int [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: (a:int []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:int64 [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: (a:int64 []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:float32 [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: (a:float32 []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:float [] * begin:int64 * end:int64) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: (a:float []) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:List<int> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: a:List<int> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:List<int64> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: a:List<int64> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:List<float32> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: a:List<float32> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:List<float> * begin:int * end:int) -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: a:List<float> -> unit

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:'T [] * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, begin, end)
Signature: (a:List<'T> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(a, count, aget, aset)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

HeapSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The HeapSort algorithm sorts the data array. It is slower than the QuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(...)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(p, a, cmp)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(...)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(p, a, cmp)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(...)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(p, a, cmp)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(p, a, aget, cmp)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSort(p, a, aget, cmp)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:int [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:int []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:int [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int64 [] * a:int []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:int64 [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:int64 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:int64 [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:float32 [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:float32 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:float32 [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:float [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:float []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:float [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int64 [] * a:float []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<int> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:List<int>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<int64> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<float32> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<float> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:List<float>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a, aget)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(p, a, aget)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:int [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:int []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:int [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int64 [] * a:int []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:int64 [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:int64 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:int64 [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:float32 [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:float32 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:float32 [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:float [] * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:float []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:float [] * begin:int64 * end:int64) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int64 [] * a:float []) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<int> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:List<int>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<int64> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<float32> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<float> * begin:int * end:int) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:List<float>) -> unit

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * begin:int * end:int) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * begin:int64 * end:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationHeapSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationHeapSort algorithm sorts the array of element indices p that reference the elements in the data array. It is slower than the PermutationQuickSort algorithm, but is not affected by the data distribution in any way, even if there are a huge number of equal data elements.

PermutationQuickMedian(p, a, cmp, med)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedian(...)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedian(p, a, cmp, med)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedian(...)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedian(p, a, cmp, med)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedian(...)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedian(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedian(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedian(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedian(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:int [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:int [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:int [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:int [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:int64 [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:int64 [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:int64 [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:int64 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:float32 [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:float32 [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:float32 [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:float32 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:float [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:float [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:float [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:float [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<int> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<int> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<int64> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<int64> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<float32> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<float32> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<float> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<float> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:int [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:int [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:int [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:int [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:int64 [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:int64 [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:int64 [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:int64 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:float32 [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:float32 [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:float32 [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:float32 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:float [] * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:float [] * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:float [] * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:float [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<int> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<int> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<int64> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<int64> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<float32> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<float32> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<float> * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<float> * beginIncl:int * endExcl:int * med:int) -> unit

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position.

PermutationQuickMedianDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array in such a way that p[med] is placed at the correct position, and correctly partitions this array range into larger and smaller elements.

PermutationQuickSort(p, a, cmp)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSort(...)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSort(p, a, cmp)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSort(...)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSort(p, a, cmp)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSort(...)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSort(p, a, aget, cmp)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSort(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSort(p, a, aget, cmp)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSort(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:int []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:int [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int64 [] * a:int []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:int [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:int64 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:int64 [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:float32 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:float32 [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:float []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:float [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int64 [] * a:float []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:float [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:List<int>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<int> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<int64> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<float32> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:List<float>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<float> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:int []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:int [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int64 [] * a:int []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:int [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:int64 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:int64 [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:float32 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:float32 [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:float []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:float [] * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int64 [] * a:float []) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:float [] * beginIncl:int64 * endExcl:int64) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:List<int>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<int> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<int64> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<float32> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:List<float>) -> unit

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<float> * beginIncl:int * endExcl:int) -> unit

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the array of element indices p that reference the elements in the data array.

PermutationQuickSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The PermutationQuickSort algorithm sorts the range [beginIncl, endExcl) of the array of element indices p that reference the elements in the data array.

PermutationSmoothSort(p, a, cmp)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSort(...)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSort(p, a, cmp)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSort(...)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSort(p, a, cmp)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSort(...)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSort(p, a, aget, cmp)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSort(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSort(p, a, aget, cmp)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSort(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:int []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:int [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int64 [] * a:int []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:int [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:int64 []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:int64 [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:float32 []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:float32 [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:float []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:float [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int64 [] * a:float []) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:float [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:List<int>) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<int> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<int64> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<float32> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:List<float>) -> unit
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<float> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:int []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:int [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int64 [] * a:int []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:int [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:int64 []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:int64 [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:float32 []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:float32 [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:float []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:float [] * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int64 [] * a:float []) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:float [] * beginIncl:int64 * endExcl:int64) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:List<int>) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<int> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<int64> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<float32> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:List<float>) -> unit
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<float> * beginIncl:int * endExcl:int) -> unit
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T
PermutationSmoothSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
PermutationTimSort(p, a, cmp)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, cmp, lo, hi)
Signature: (p:int [] * a:'T [] * cmp:Func<'T,'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, cmp)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, cmp, lo, hi)
Signature: (p:int64 [] * a:'T [] * cmp:Func<'T,'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, cmp)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, cmp, lo, hi)
Signature: (p:int [] * a:List<'T> * cmp:Func<'T,'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, aget, cmp)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(p, a, aget, cmp)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSort(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * cmp:Func<'T,'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:int []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:int [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int64 [] * a:int []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:int [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:int64 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:int64 [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:int64 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:float32 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:float32 [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:float32 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:float []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:float [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int64 [] * a:float []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:float [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:List<int>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<int> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<int64> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<float32> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:List<float>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<float> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a, aget)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(p, a, aget)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortAscending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:int []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:int [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int64 [] * a:int []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:int [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:int64 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:int64 [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int64 [] * a:int64 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:int64 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:float32 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:float32 [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int64 [] * a:float32 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:float32 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:float []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:float [] * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int64 [] * a:float []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:float [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:List<int>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<int> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:List<int64>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<int64> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:List<float32>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<float32> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:List<float>) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<float> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:'T []) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int64 [] * a:'T []) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'T [] * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'T [] * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a)
Signature: (p:int [] * a:List<'T>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:List<'T> * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a, aget)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(p, a, aget)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

PermutationTimSortDescending(...)
Signature: (p:int64 [] * a:'TArray * aget:Func<'TArray,int64,'T> * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

QuickMedian(a, cmp, med)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedian(...)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedian(a, cmp, med)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedian(...)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedian(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedian(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:int [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:int [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:int64 [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:int64 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:float32 [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:float32 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:float [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:float [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:List<int> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<int> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:List<int64> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<int64> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:List<float32> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<float32> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:List<float> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<float> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:'T [] * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, med)
Signature: (a:List<'T> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<'T> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:int [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:int [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:int64 [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:int64 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:float32 [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:float32 [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:float [] * med:int64) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:float [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:List<int> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<int> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:List<int64> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<int64> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:List<float32> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<float32> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:List<float> * med:int) -> unit

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<float> * beginIncl:int * endExcl:int * med:int) -> unit

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:'T [] * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:'T [] * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, med)
Signature: (a:List<'T> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<'T> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,int> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,int64> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,float32> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(a, selector, med)
Signature: (a:List<'T> * selector:Func<'T,float> * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int * med:int) -> unit
Type parameters: 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the data array in such a way that the element at position med is correctly placed, and correctly partitions the array into larger and smaller elements.

QuickMedianDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64 * med:int64) -> unit
Type parameters: 'TArray, 'T

The QuickMedian algorithm partially sorts the range [beginIncl, endExcl) of the data array in such a way that the element at position med is correctly placed, and correctly partitions this array range into larger and smaller elements.

QuickSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSort(a, cmp, beginIncl, endExcl)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSort(a, cmp, beginIncl, endExcl)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSort(a, count, aget, aset, cmp)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSort(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: (a:int []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:int [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: (a:int64 []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: (a:float32 []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: (a:float []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:float [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: a:List<int> -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<int> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: a:List<int64> -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<int64> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: a:List<float32> -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<float32> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: a:List<float> -> unit

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<float> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(a, count, aget, aset)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: (a:int []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:int [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: (a:int64 []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: (a:float32 []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: (a:float []) -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:float [] * beginIncl:int64 * endExcl:int64) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: a:List<int> -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<int> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: a:List<int64> -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<int64> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: a:List<float32> -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<float32> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: a:List<float> -> unit

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<float> * beginIncl:int * endExcl:int) -> unit

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

QuickSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the data array.

QuickSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T

The QuickSort algorithm sorts the range [beginIncl, endExcl) of the array of elements in the data array.

ReverseRange(a, beginIncl, endExcl)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
ReverseRange(a, beginIncl, endExcl)
Signature: (a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
ReverseRange(...)
Signature: (aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * a:'TArray * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T
SmoothSort(a, cmp, beginIncl, endExcl)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T
SmoothSort(a, cmp, beginIncl, endExcl)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSort(a, count, aget, aset, cmp)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T
SmoothSort(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * cmp:Func<'T,'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(a)
Signature: (a:int []) -> unit
SmoothSortAscending(...)
Signature: (a:int [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortAscending(a)
Signature: (a:int64 []) -> unit
SmoothSortAscending(...)
Signature: (a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortAscending(a)
Signature: (a:float32 []) -> unit
SmoothSortAscending(...)
Signature: (a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortAscending(a)
Signature: (a:float []) -> unit
SmoothSortAscending(...)
Signature: (a:float [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortAscending(a)
Signature: a:List<int> -> unit
SmoothSortAscending(...)
Signature: (a:List<int> * beginIncl:int * endExcl:int) -> unit
SmoothSortAscending(a)
Signature: a:List<int64> -> unit
SmoothSortAscending(...)
Signature: (a:List<int64> * beginIncl:int * endExcl:int) -> unit
SmoothSortAscending(a)
Signature: a:List<float32> -> unit
SmoothSortAscending(...)
Signature: (a:List<float32> * beginIncl:int * endExcl:int) -> unit
SmoothSortAscending(a)
Signature: a:List<float> -> unit
SmoothSortAscending(...)
Signature: (a:List<float> * beginIncl:int * endExcl:int) -> unit
SmoothSortAscending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortAscending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T
SmoothSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(a)
Signature: (a:int []) -> unit
SmoothSortDescending(...)
Signature: (a:int [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortDescending(a)
Signature: (a:int64 []) -> unit
SmoothSortDescending(...)
Signature: (a:int64 [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortDescending(a)
Signature: (a:float32 []) -> unit
SmoothSortDescending(...)
Signature: (a:float32 [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortDescending(a)
Signature: (a:float []) -> unit
SmoothSortDescending(...)
Signature: (a:float [] * beginIncl:int64 * endExcl:int64) -> unit
SmoothSortDescending(a)
Signature: a:List<int> -> unit
SmoothSortDescending(...)
Signature: (a:List<int> * beginIncl:int * endExcl:int) -> unit
SmoothSortDescending(a)
Signature: a:List<int64> -> unit
SmoothSortDescending(...)
Signature: (a:List<int64> * beginIncl:int * endExcl:int) -> unit
SmoothSortDescending(a)
Signature: a:List<float32> -> unit
SmoothSortDescending(...)
Signature: (a:List<float32> * beginIncl:int * endExcl:int) -> unit
SmoothSortDescending(a)
Signature: a:List<float> -> unit
SmoothSortDescending(...)
Signature: (a:List<float> * beginIncl:int * endExcl:int) -> unit
SmoothSortDescending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:'T [] * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:'T [] * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'T
SmoothSortDescending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:List<'T> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,int64> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float32> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:List<'T> * selector:Func<'T,float> * beginIncl:int * endExcl:int) -> unit
Type parameters: 'T
SmoothSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T>) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,int64> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float32> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T
SmoothSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * selector:Func<'T,float> * beginIncl:int64 * endExcl:int64) -> unit
Type parameters: 'TArray, 'T
TimSort(a, cmp)
Signature: (a:'T [] * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSort(a, cmp, lo, hi)
Signature: (a:'T [] * cmp:Func<'T,'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSort(a, cmp)
Signature: (a:List<'T> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSort(a, cmp, lo, hi)
Signature: (a:List<'T> * cmp:Func<'T,'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSort(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * cmp:Func<'T,'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSort(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * cmp:Func<'T,'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: (a:int []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:int [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: (a:int64 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:int64 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: (a:float32 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:float32 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: (a:float []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:float [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: a:List<int> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:List<int> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: a:List<int64> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:List<int64> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: a:List<float32> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:List<float32> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: a:List<float> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:List<float> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:'T [] * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, lo, hi)
Signature: (a:List<'T> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortAscending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: (a:int []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:int [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: (a:int64 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:int64 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: (a:float32 []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:float32 [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: (a:float []) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:float [] * lo:int64 * hi:int64) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: a:List<int> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:List<int> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: a:List<int64> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:List<int64> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: a:List<float32> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:List<float32> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: a:List<float> -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:List<float> * lo:int * hi:int) -> unit

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: (a:'T []) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:'T [] * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:'T [] * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:'T [] * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a)
Signature: a:List<'T> -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, lo, hi)
Signature: (a:List<'T> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,int> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,int64>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,int64> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float32>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,float32> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector)
Signature: (a:List<'T> * selector:Func<'T,float>) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(a, selector, lo, hi)
Signature: (a:List<'T> * selector:Func<'T,float> * lo:int * hi:int) -> unit
Type parameters: 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int64>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,int64> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float32>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float32> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * count:int64 * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float>) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

TimSortDescending(...)
Signature: (a:'TArray * aget:Func<'TArray,int64,'T> * aset:Action<'TArray,int64,'T> * amake:Func<int64,'TArray> * selector:Func<'T,float> * lo:int64 * hi:int64) -> unit
Type parameters: 'TArray, 'T

The TimSort algorithm is not as fast as QuickSort for completely randomized arrays, but is a bit faster for mostly sorted or mostly reversed arrays. Additionally it is a stable algorithm.

Fork me on GitHub