Ternary search

A ternary search algorithm is a technique in computer science for finding the minimum or maximum of a unimodal function. A ternary search determines either that the minimum or maximum cannot be in the first third of the domain or that it cannot be in the last third of the domain, then repeats on the remaining two thirds. A ternary search is an example of a divide and conquer algorithm (see search algorithm).

The function[]

Assume we are looking for a maximum of f(x) and that we know the maximum lies somewhere between A and B. For the algorithm to be applicable, there must be some value x such that

• for all a,b with A ≤ a < b ≤ x, we have f(a) < f(b), and
• for all a,b with x ≤ a < b ≤ B, we have f(a) > f(b).

Algorithm[]

Let f(x) be a unimodal function on some interval [l; r]. Take any two points m₁ and m₂ in this segment: l < m₁ < m₂ < r. Then there are three possibilities:

• if f(m₁) < f(m₂), then the required maximum can not be located on the left side - [l; m₁]. It means that the maximum further makes sense to look only in the interval [m₁;r]
• if f(m₁) > f(m₂), that the situation is similar to the previous, up to symmetry. Now, the required maximum can not be in the right side - [m₂; r], so go to the segment [l; m₂]
• if f(m₁) = f(m₂), then the search should be conducted in [m₁; m₂], but this case can be attributed to any of the previous two (in order to simplify the code). Sooner or later the length of the segment will be a little less than a predetermined constant, and the process can be stopped.

choice points m₁ and m₂:

• m₁ = l + (r-l)/3
• m₂ = r - (r-l)/3

Run time order

${\displaystyle T(n)=T(2n/3)+1=\Theta (\log n)}$

Recursive algorithm[]

def ternary_search(f, left, right, absolute_precision) -> float:
    """Left and right are the current bounds;
    the maximum is between them.
    """
    if abs(right - left) < absolute_precision:
        return (left + right) / 2

    left_third = (2*left + right) / 3
    right_third = (left + 2*right) / 3

    if f(left_third) < f(right_third):
        return ternary_search(f, left_third, right, absolute_precision)
    else:
        return ternary_search(f, left, right_third, absolute_precision)

Iterative algorithm[]

def ternary_search(f, left, right, absolute_precision) -> float:
    """Find maximum of unimodal function f() within [left, right]
    To find the minimum, reverse the if/else statement or reverse the comparison.
    """
    while abs(right - left) >= absolute_precision:
        left_third = left + (right - left) / 3
        right_third = right - (right - left) / 3

        if f(left_third) < f(right_third):
            right = right_third
        else:
            left = left_third

     # Left and right are the current bounds; the maximum is between them
     return (left + right) / 2

See also[]

• Newton's method in optimization (can be used to search for where the derivative is zero)
• Golden-section search (similar to ternary search, useful if evaluating f takes most of the time per iteration)
• Binary search algorithm (can be used to search for where the derivative changes in sign)
• Interpolation search
• Exponential search
• Linear search
• N Dimensional Ternary Search Implementation

References[]

This article does not cite any sources. Please help by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources:  –  ·  ·  · scholar · JSTOR (May 2007) (Learn how and when to remove this template message)