Editing Ternary search

'''Ternary search''' is an algorithm similar to [[binary search]]. It is used when we have a function that is bitonic on a given interval instead of monotone, and we wish to optimize its value on that interval. That is, either the function first increases and then decreases, and we wish to find its maximum (that is, where it changes from increasing to decreasing), or it first decreases and then increases, and we wish to find the minimum. (In the former case, finding the minimum is trivial; it is at either the left edge or the right edge of the interval. In the latter case, finding the maximum is trivial.)

For the algorithm to work, we need the increase and decrease to be strict. Otherwise, we could have a pathological case in which the function is constant at all but one point, and then it would be impossible to find that point in the continuous case (and would be impossible to do it efficiently in the discrete case).

Should we wish to find a specific value, we can use binary search on the increasing part and the decreasing part separately, after having located the extremum and hence determined where the increasing part and decreasing part begin and end.

The function in question is usually defined on a continuous domain rather than a discrete domain, which gives the following pseudocode for the increasing-then-decreasing case:
<pre>
// a: left edge of interval
// b: right edge of interval
// f: function
// epsilon: tolerance
input a, b, f, epsilon
l &larr; a
r &larr; b
while (r-l &gt; epsilon)
    m1 &larr; (2*l + r)/3
    m2 &larr; (l + 2*r)/3
    if f(m1) < f(m2)
        l &larr; m1
    else
        r &larr; m2
print r
</pre>

The reasoning is as follows. We split the interval <math>[l, r]</math> into three equal subintervals: <math>[l, m_1]</math>, <math>[m_1, m_2]</math>, and <math>[m_2, r]</math>. Then we evaluate <math>f</math> at the intermediate points <math>m_1</math> and <math>m_2</math>. We then consider the result of the comparison:
* If <math>f(m_1) < f(m_2)</math>, then the maximum can't possibly occur in the first interval, since then the function would be increasing from <math>f(a)</math> to the maximum, then decreasing from the maximum to <math>f(m_1)</math>, and then at some point increasing again since <math>f(m_2) > f(m_1)</math>. So we discard the first interval.
* If <math>f(m_1) > f(m_2)</math>, then the maximum can't possibly occur in the third interval, by similar reasoning.
* If <math>f(m_1) = f(m_2)</math>, then the maximum has to be in the second interval; if it were in the first interval then the function would not be strictly decreasing afterward, and if it were in the third interval then the function would not be strictly increasing at the beginning.
Here, we can either discard the first or the third interval; it doesn't matter which. That's why we don't need a case in the code for this case.
Intuitively, evaluating the function at the two intermediate points tips us off as to which "direction" to look in, as though we are climbing a hill. When the function is higher at the first than at the second, we know the maximum lies in one of the two left subintervals, and when it is higher at the second than at the first, we know the maximum lies in one of the two right subintervals. If the bitonicity is not strict, then we might not be able to obtain any useful information from the comparison, so this is not allowed.

The loop runs about <math>\log_{3/2}\frac{b-a}{\epsilon}</math> times, since each iteration reduces the length of the interval <math>[l,r]</math> by a factor of <math>\frac{3}{2}</math>. Each iteration involves two evaluations of the function, so the total number of evaluations is about <math>2\log_{3/2}\frac{b-a}{\epsilon}</math>. This is <math>\Theta\left(\log(b-a) + \log\frac{1}{\epsilon}\right)</math>, so the smaller the epsilon, the longer the search takes, but overall the time is logarithmic in the length of the initial interval.

An example application of ternary search is finding a point <math>Q_0</math> on a line segment <math>\ell</math> such that the distance <math>|PQ_0|</math> is minimal (where point <math>P</math> is given). Although there is a direct mathematical solution to this problem, an easier solution that allows us to approximate <math>Q_0</math> is to parameterize the line segment: let <math>Q(t)</math> be the point on the line segment that is a distance <math>t</math> from one of the endpoints, and then notice that <math>|PQ(t)|</math> is a bitonic function whose minimum we wish to find (this can easily be proven using the Pythagorean theorem). Thus, ternary search can be used to find the point. Intuitively, we divide the line segment into thirds, and measure the distance from <math>P</math> to each of the two dividing points, thus discarding one third of the segment, and repeating as far as necessary.