std.algorithm.comparison

This is a submodule of std.algorithm. It contains generic comparison algorithms.

Cheat Sheet
Function Name	Description
among	Checks if a value is among a set of values, e.g. `if (v.among(1, 2, 3)) //` v `is 1, 2 or 3`
castSwitch	`(new A()).castSwitch((A a)=>1,(B b)=>2)` returns `1`.
clamp	`clamp(1, 3, 6)` returns `3`. `clamp(4, 3, 6)` returns `4`.
cmp	`cmp("abc", "abcd")` is `-1`, `cmp("abc", "aba")` is `1`, and `cmp("abc", "abc")` is `0`.
either	Return first parameter `p` that passes an `if (p)` test, e.g. `either(0, 42, 43)` returns `42`.
equal	Compares ranges for element-by-element equality, e.g. `equal([1, 2, 3], [1.0, 2.0, 3.0])` returns `true`.
isPermutation	`isPermutation([1, 2], [2, 1])` returns `true`.
isSameLength	`isSameLength([1, 2, 3], [4, 5, 6])` returns `true`.
levenshteinDistance	`levenshteinDistance("kitten", "sitting")` returns `3` by using the Levenshtein distance algorithm.
levenshteinDistanceAndPath	`levenshteinDistanceAndPath("kitten", "sitting")` returns `tuple(3, "snnnsni")` by using the Levenshtein distance algorithm.
max	`max(3, 4, 2)` returns `4`.
min	`min(3, 4, 2)` returns `2`.
mismatch	`mismatch("oh hi", "ohayo")` returns `tuple(" hi", "ayo")`.
predSwitch	`2.predSwitch(1, "one", 2, "two", 3, "three")` returns `"two"`.

Members

Enums

EditOp enum EditOp: Encodes edit operations necessary to transform one sequence into another. Given sequences s (source) and t (target), a sequence of EditOp encodes the steps that need to be taken to convert s into t. For example, if s = "cat" and "cars", the minimal sequence that transforms s into t is: skip two characters, replace 't' with 'r', and insert an 's'. Working with edit operations is useful in applications such as spell-checkers (to find the closest word to a given misspelled word), approximate searches, diff-style programs that compute the difference between files, efficient encoding of patches, DNA sequence analysis, and plagiarism detection.

Functions

among uint among(Value value, Values values): Find value among values, returning the 1-based index of the first matching value in values, or 0 if value is not among values. The predicate pred is used to compare values, and uses equality by default.
castSwitch auto castSwitch(Object switchObject): Executes and returns one of a collection of handlers based on the type of the switch object.
clamp T1 clamp(T1 val, T2 lower, T3 upper): Clamps val into the given bounds. Result has the same type as val.
cmp auto cmp(R1 r1, R2 r2)
int cmp(R1 r1, R2 r2): Performs a lexicographical comparison on two input ranges. Iterating r1 and r2 in lockstep, cmp compares each element e1 of r1 with the corresponding element e2 in r2. If one of the ranges has been finished, cmp returns a negative value if r1 has fewer elements than r2, a positive value if r1 has more elements than r2, and 0 if the ranges have the same number of elements.
either CommonType!(T, Ts) either(T first, Ts alternatives): Get the first argument a that passes an if (unaryFun!pred(a)) test. If no argument passes the test, return the last argument.
isPermutation bool isPermutation(Range1 r1, Range2 r2): Checks if both ranges are permutations of each other.
isSameLength bool isSameLength(Ranges rs): Checks if two or more ranges have the same number of elements. This function is optimized to always take advantage of the length member of either range if it exists.
levenshteinDistance size_t levenshteinDistance(Range1 s, Range2 t): Returns the Levenshtein distance between s and t. The Levenshtein distance computes the minimal amount of edit operations necessary to transform s into t. Performs O(s.length * t.length) evaluations of equals and occupies O(min(s.length, t.length)) storage.
levenshteinDistanceAndPath Tuple!(size_t, EditOp[]) levenshteinDistanceAndPath(Range1 s, Range2 t): Returns the Levenshtein distance and the edit path between s and t.
max auto max(T args)
T max(T a, U b): Iterates the passed arguments and returns the maximum value.
min auto min(T args)
T min(T a, U b): Iterates the passed arguments and returns the minimum value.
mismatch Tuple!(Ranges) mismatch(Ranges rs): Sequentially compares elements in rs in lockstep, and stops at the first mismatch (according to pred, by default equality). Returns a tuple with the reduced ranges that start with the two mismatched values. Performs O(min(r[0].length, r[1].length, ...)) evaluations of pred.
predSwitch auto predSwitch(T switchExpression, R choices): Returns one of a collection of expressions based on the value of the switch expression.

Templates

among template among(values...): Find value among values, returning the 1-based index of the first matching value in values, or 0 if value is not among values. The predicate pred is used to compare values, and uses equality by default.
equal template equal(alias pred = "a == b"): Compares two or more ranges for equality, as defined by predicate pred (which is == by default).

The OpenD Programming Language

std.algorithm.comparison

Members

Enums

Functions

Templates

Meta

Source

License

Copyright

Authors