algorithm

nimony/lib/std/algorithm.nim

• type SortOrder = enum
    Descending = (0, "Descending")
    Ascending = (1, "Ascending")

• func dollar`.SortOrder(e: SortOrder): string
• func *(x: int64; order: SortOrder): int64

  Flips the sign of x if order == Descending. If order == Ascending then x is returned.

  x is supposed to be the result of a comparator, i.e.

  | < 0 for less than,

  | == 0 for equal,

  | > 0 for greater than.

• proc sort(a: var openArray[T]; cmp: proc (x: T, y: T): int64; order: SortOrder)

  Default Nim sort (an implementation of merge sort). The sorting is guaranteed to be stable (that is, equal elements stay in the same order) and the worst case is guaranteed to be O(n log n). Sorts by cmp in the specified order.

  The current implementation uses an iterative mergesort to achieve this. It uses a temporary sequence of length a.len div 2. If you do not wish to provide your own cmp, you may use system.cmp or instead call the overloaded version of sort, which uses system.cmp.

  nim sort(myIntArray, system.cmp[int]) # do not use cmp[string] here as we want to use the specialized # overload: sort(myStrArray, system.cmp)

  You can inline adhoc comparison procs with the do notation. Example:

  nim people.sort do (x, y: Person) -> int: result = cmp(x.surname, y.surname) if result == 0: result = cmp(x.name, y.name)

  See also:

  • sort proc<#sort,openArray[T]>_
  • sorted proc<#sorted,openArray[T],proc(T,T)>_ sorted by cmp in the specified order
  • sorted proc<#sorted,openArray[T]>_
  • sortedByIt template<#sortedByIt.t,untyped,untyped>_
• proc sorted(a: openArray[T]; cmp: proc (x: T, y: T): int64; order: SortOrder): seq[T]

  Returns a sorted by cmp in the specified order.

  See also:

  • sort func<#sort,openArray[T],proc(T,T)>_
  • sort proc<#sort,openArray[T]>_
  • sortedByIt template<#sortedByIt.t,untyped,untyped>_
• proc isSorted(a: openArray[T]; cmp: proc (x: T, y: T): int64; order: SortOrder): bool

  Checks to see whether a is already sorted in order using cmp for the comparison. The parameters are identical to sort. Requires O(n) time.

  See also:

  • isSorted proc<#isSorted,openArray[T]>_