!V\      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX Y Z [ (c) 2008-2011 Dan DoelDan Doel ExperimentalPortableNone>HVvector-algorithms9A type of comparisons between two values of a given type.\]^_(c) 2008-2010 Dan DoelDan Doel ExperimentalPortableNonevector-algorithms$Sorts the elements at the positions off8 and 'off + 1' in the given array using the comparison.vector-algorithmsSorts the elements at the two given indices using the comparison. This is essentially a compare-and-swap, although the first index is assumed to be the lower of the two.vector-algorithmsCSorts the three elements starting at the given offset in the array.vector-algorithmsSorts the elements at the three given indices. The indices are assumed to be given from lowest to highest, so if 'l < m < u' then 'sort3ByIndex cmp a m l u' essentially sorts the median of three into the lowest position in the array.vector-algorithms0Sorts the four elements beginning at the offset.vector-algorithmsSorts the elements at the four given indices. Like the 2 and 3 element versions, this assumes that the indices are given in increasing order, so it can be used to sort medians into particular positions and so on.(c) 2008-2010 Dan DoelDan Doel ExperimentalPortableNoneHVvector-algorithms?Sorts an entire array using the default comparison for the typevector-algorithms.Sorts an entire array using a given comparison vector-algorithms0Sorts the portion of an array delimited by [l,u) vector-algorithmseSorts the portion of the array delimited by [l,u) under the assumption that [l,m) is already sorted.  (c) 2008-2011 Dan DoelDan Doel <dan.doel@gmail.com> ExperimentalPortableNoneHV!A vector-algorithms,Sorts an array using the default comparison. vector-algorithms)Sorts an array using a custom comparison.  (c) 2011 Dan DoelDan Doel <dan.doel@gmail.com> Experimental4Non-portable (FlexibleContexts, ScopedTypeVariables)None>HVX9O vector-algorithmsqThe methods of this class specify the information necessary to sort arrays using the default ordering. The name  b is meant to convey that index should return results in a similar way to indexing into a string.vector-algorithmsDComputes the length of a representative of a stripe. It should take n" passes to sort values of extent n?. The extent may not be uniform across all values of the type.vector-algorithms5The size of the bucket array necessary for sorting esvector-algorithmsSDetermines which bucket a given element should inhabit for a particular iteration.vector-algorithmsjGiven a representative of a stripe and an index number, this function determines whether to stop sorting.vector-algorithmsSorts an array using the default ordering. Both Lexicographic and Ord are necessary because the algorithm falls back to insertion sort for sufficiently small arrays.vector-algorithmsA fully parameterized version of the sorting algorithm. Again, this function takes both radix information and a comparison, because the algorithms falls back to insertion sort for small arrays.vector-algorithms,a comparison for the insertion sort flalbackvector-algorithms'determines whether a stripe is completevector-algorithmsthe number of buckets necessaryvector-algorithmsthe big-endian radix functionvector-algorithmsthe array to be sorted  (c) 2008-2015 Dan DoelDan Doel <dan.doel@gmail.com> ExperimentalNon-portable (type operators)NoneHUVo!vector-algorithms1Sorts an entire array using the default ordering."vector-algorithms.Sorts an entire array using a custom ordering.#vector-algorithms9Sorts a portion of an array [l,u) using a custom ordering$vector-algorithmsdMoves the lowest k elements to the front of the array. The elements will be in no particular order.%vector-algorithmsMoves the lowest (as defined by the comparison) k elements to the front of the array. The elements will be in no particular order.&vector-algorithms Moves the lowestx k elements in the portion [l,u) of the array into the positions [l,k+l). The elements will be in no particular order.'vector-algorithms>Moves the lowest k elements to the front of the array, sorted.AThe remaining values of the array will be in no particular order.(vector-algorithms^Moves the lowest k elements (as defined by the comparison) to the front of the array, sorted.AThe remaining values of the array will be in no particular order.)vector-algorithms^Moves the lowest k elements in the portion [l,u) of the array into positions [l,k+l), sorted.qThe remaining values in [l,u) will be in no particular order. Values outside the range [l,u) will be unaffected.*vector-algorithmsLConstructs a heap in a portion of an array [l, u), using the values therein.Note: *w is more efficient than constructing a heap by repeated insertion. Repeated insertion has complexity O(n*log n) while *U is able to construct a heap in O(n), where n is the number of elements in the heap.+vector-algorithms{Given a heap stored in a portion of an array [l,u), swaps the top of the heap with the element at u and rebuilds the heap.,vector-algorithmsGiven a heap stored in a portion of an array [l,u) swaps the top of the heap with the element at position t, and rebuilds the heap.-vector-algorithmsGiven a heap stored in a portion of an array [l,u), sorts the highest values into [m,u). The elements in [l,m) are not in any particular order..vector-algorithmsGiven a heap stored in a portion of an array [l,u) and an element e, inserts the element into the heap, resulting in a heap in [l,u].bNote: it is best to only use this operation when incremental construction of a heap is required. *] is capable of building a heap in O(n) time, while repeated insertion takes O(n*log n) time. #vector-algorithmslower index, lvector-algorithmsupper index, u$vector-algorithmsnumber of elements to select, k%vector-algorithmsnumber of elements to select, k&vector-algorithmsnumber of elements to select, kvector-algorithmslower index, lvector-algorithmsupper index, u'vector-algorithmsnumber of elements to sort, k(vector-algorithmsnumber of elements to sort, k)vector-algorithmsnumber of elements to sort, kvector-algorithmslower index, lvector-algorithmsupper index, u*vector-algorithmslower index, lvector-algorithmsupper index, u+vector-algorithmslower heap index, lvector-algorithmsupper heap index, u,vector-algorithmslower heap index, lvector-algorithmsupper heap index, uvector-algorithmsindex to pop to, t-vector-algorithmslower heap index, lvector-algorithms&lower bound of final sorted portion, mvector-algorithmsupper heap index, u.vector-algorithmslower heap index, lvector-algorithmsupper heap index, uvector-algorithmselement to be inserted, e!"#$%&'()*+,-.!"#$%&'()*+,-.(c) 2008-2015 Dan DoelDan Doel <dan.doel@gmail.com> Experimental,Non-portable (type operators, bang patterns)NoneHUVX /vector-algorithms1Sorts an entire array using the default ordering.0vector-algorithms.Sorts an entire array using a custom ordering.1vector-algorithms9Sorts a portion of an array [l,u) using a custom ordering2vector-algorithmsMMoves the least k elements to the front of the array in no particular order.3vector-algorithmslMoves the least k elements (as defined by the comparison) to the front of the array in no particular order.4vector-algorithmsbMoves the least k elements in the interval [l,u) to the positions [l,k+l) in no particular order.5vector-algorithms=Moves the least k elements to the front of the array, sorted.6vector-algorithms]Moves the least k elements (as defined by the comparison) to the front of the array, sorted.7vector-algorithmsSMoves the least k elements in the interval [l,u) to the positions [l,k+l), sorted.1vector-algorithmslower index, lvector-algorithmsupper index, u2vector-algorithmsnumber of elements to select, k3vector-algorithmsnumber of elements to select, k4vector-algorithmsnumber of elements to select, kvector-algorithmslower bound, lvector-algorithmsupper bound, u5vector-algorithmsnumber of elements to sort, k6vector-algorithmsnumber of elements to sort, k7vector-algorithmsnumber of elements to sort, kvector-algorithmslower index, lvector-algorithmsupper index, u /01234567 /01234567(c) 2008-2011 Dan DoelDan Doel <dan.doel@gmail.com> Experimental3Non-portable (scoped type variables, bang patterns)NoneHUVXy9vector-algorithms5The number of passes necessary to sort an array of es:vector-algorithmsThe size of an auxiliary array;vector-algorithms4The radix function parameterized by the current pass<vector-algorithms+Sorts an array based on the Radix instance.=vector-algorithmsCRadix sorts an array using custom radix information requires the number of passes to fully sort the array, the size of of auxiliary arrays necessary (should be one greater than the maximum value returned by the radix function), and a radix function, which takes the pass and an element, and returns the relevant radix.=vector-algorithmsthe number of passesvector-algorithmsthe size of auxiliary arraysvector-algorithmsthe radix functionvector-algorithmsthe array to be sorted8:;9<=<=8:;9((c) 2009-2015 Dan Doel, 2015 Tim BaumannDan Doel <dan.doel@gmail.com> ExperimentalNon-portable (bang patterns)NoneHVϯIvector-algorithmsFinds an index in a given sorted vector at which the given element could be inserted while maintaining the sortedness of the vector.Jvector-algorithmsFinds an index in a given vector, which must be sorted with respect to the given comparison function, at which the given element could be inserted while preserving the vector's sortedness.Kvector-algorithmsGiven a vector sorted with respect to a given comparison function in indices in [l,u), finds an index in [l,u] at which the given element could be inserted while preserving sortedness.Lvector-algorithmsFinds the lowest index in a given sorted vector at which the given element could be inserted while maintaining the sortedness.Mvector-algorithmsFinds the lowest index in a given vector, which must be sorted with respect to the given comparison function, at which the given element could be inserted while preserving the sortedness.Nvector-algorithmsGiven a vector sorted with respect to a given comparison function on indices in [l,u), finds the lowest index in [l,u] at which the given element could be inserted while preserving sortedness.Ovector-algorithms}Finds the greatest index in a given sorted vector at which the given element could be inserted while maintaining sortedness.Pvector-algorithmsFinds the greatest index in a given vector, which must be sorted with respect to the given comparison function, at which the given element could be inserted while preserving the sortedness.Qvector-algorithmsGiven a vector sorted with respect to the given comparison function on indices in [l,u), finds the greatest index in [l,u] at which the given element could be inserted while preserving sortedness.Rvector-algorithmsGiven a predicate that is guaraneteed to be monotone on the given vector, finds the first index at which the predicate returns True, or the length of the array if the predicate is false for the entire array.Svector-algorithmsGiven a predicate that is guaranteed to be monotone on the indices [l,u) in a given vector, finds the index in [l,u] at which the predicate turns from False to True (yielding u if the entire interval is False).Tvector-algorithmsGiven a predicate that is guaranteed to be monotone on the vector elements in order, finds the index at which the predicate turns from False to True. The length of the vector is returned if the predicate is False for the entire vector.MBegins searching at the start of the vector, in increasing steps of size 2^n.Uvector-algorithmsGiven a predicate that is guaranteed to be monotone on the vector elements in order, finds the index at which the predicate turns from False to True. The length of the vector is returned if the predicate is False for the entire vector.KBegins searching at the end of the vector, in increasing steps of size 2^n.Vvector-algorithmsGiven a predicate that is guaranteed to be monotone on the indices [l,u) in a given vector, finds the index in [l,u] at which the predicate turns from False to True (yielding u if the entire interval is False). Begins searching at l, going right in increasing (2^n)-steps.Wvector-algorithmsGiven a predicate that is guaranteed to be monotone on the indices [l,u) in a given vector, finds the index in [l,u] at which the predicate turns from False to True (yielding u if the entire interval is False). Begins searching at u, going left in increasing (2^n)-steps.Vvector-algorithmslvector-algorithmsuWvector-algorithmslvector-algorithmsuIJKLMNOPQRSTUVWIJKLMNOPQRSTVUW ((c) 2013-2015 Dan Doel, 2015 Tim BaumannDan Doel <dan.doel@gmail.com> ExperimentalNon-portable (bang patterns)None Xvector-algorithms,Sorts an array using the default comparison.Yvector-algorithms)Sorts an array using a custom comparison.`vector-algorithmsComputes the minimum run size for the sort. The goal is to choose a size such that there are almost if not exactly 2^n chunks of that size in the array.avector-algorithmsIdentify the next run (that is a monotonically increasing or strictly decreasing sequence) in the slice [l,u) in vec. Returns the order and length of the run.bvector-algorithmsTests if a temporary buffer has a given size. If not, allocates a new buffer and returns it instead of the old temporary buffer.cvector-algorithmsCopy the slice [i,i+len) from vec to tmpBuf. If tmpBuf is not large enough, a new buffer is allocated and used. Returns the buffer.dvector-algorithmslNumber of consecutive times merge chooses the element from the same run before galloping mode is activated.evector-algorithmsMerge the adjacent sorted slices [l,m) and [m,u) in vec. This is done by copying the slice [l,m) to a temporary buffer. Returns the (enlarged) temporary buffer.fvector-algorithmsMerge the adjacent sorted slices [l,m) and [m,u) in vec. This is done by copying the slice [j,k) to a temporary buffer. Returns the (enlarged) temporary buffer.gvector-algorithmsMerge the adjacent sorted slices A=[l,m) and B=[m,u) in vec. This begins with galloping searches to find the index of vec[m] in A and the index of vec[m-1] in B to reduce the sizes of A and B. Then it uses f or eQ depending on whether A or B is larger. Returns the (enlarged) temporary buffer.avector-algorithmslvector-algorithmsucvector-algorithmsivector-algorithmslenvector-algorithmsvecvector-algorithmstmpBufevector-algorithmsvecvector-algorithmslvector-algorithmsmvector-algorithmsuvector-algorithmstmpBuffvector-algorithmsvecvector-algorithmslvector-algorithmsmvector-algorithmsuvector-algorithmstmpBufgvector-algorithmsvecvector-algorithmslvector-algorithmsmvector-algorithmsuvector-algorithmstmpBufXYXYh     !"#$%&'()*+,-./012()*+,-3456789:;<=>?@ABCDEFGHIJKLMNO   P Q R S T U V W X Y Z [ \ ]^0vector-algorithms-0.8.0.3-4m5sdc4qkKQEhBFbLBiH6xData.Vector.Algorithms.Optimal Data.Vector.Algorithms.InsertionData.Vector.Algorithms.Merge#Data.Vector.Algorithms.AmericanFlagData.Vector.Algorithms.HeapData.Vector.Algorithms.IntroData.Vector.Algorithms.RadixData.Vector.Algorithms.SearchData.Vector.Algorithms.TimData.Vector.Algorithms.Common Comparison sort2ByOffset sort2ByIndex sort3ByOffset sort3ByIndex sort4ByOffset sort4ByIndexsortsortBy sortByBounds sortByBounds' Lexicographicextentsizeindex terminate$fLexicographicEither$fLexicographic(,)$fLexicographicByteString$fLexicographicInt$fLexicographicInt64$fLexicographicInt32$fLexicographicInt16$fLexicographicInt8$fLexicographicWord$fLexicographicWord64$fLexicographicWord32$fLexicographicWord16$fLexicographicWord8selectselectByselectByBounds partialSort partialSortBypartialSortByBoundsheapifypoppopTosortHeap heapInsertRadixpassesradix $fRadix(,) $fRadixWord64 $fRadixWord32 $fRadixWord16 $fRadixWord8 $fRadixWord $fRadixInt64 $fRadixInt32 $fRadixInt16 $fRadixInt8 $fRadixInt binarySearchbinarySearchBybinarySearchByBounds binarySearchLbinarySearchLBybinarySearchLByBounds binarySearchRbinarySearchRBybinarySearchRByBounds binarySearchPbinarySearchPBoundsgallopingSearchLeftPgallopingSearchRightPgallopingSearchLeftPBoundsgallopingSearchRightPBounds $fEqOrder $fShowOrder copyOffsetinc countLoopmidPointminrunnextRunensureCapacity cloneSlice minGallopmergeLomergeHimerge