lower bound upper bound

Question

What exactly does lower bound imply? 

If I had to guess, I'd say this function returns the iterator at the last element with a value less than the one requested. 

However, I notice that lower bound is nearly identical to upper bound. 

In the case of upper bound, the only difference is strict inequality. 

Is there a true lower bound selection function in stl that agrees with the traditional definition of the term?

EDIT: I was perplexed by the docs because there were too many negations. 

The issue was that I kept getting the same iterator. 

By subtracting 1 from the lower bound return value, I was able to solve the problem. 

It's what I use for interpolation:

float operator()(double f) { SpectrumPoint* l=std::lower_bound(beginGet(),endGet(),(SpectrumPoint){float(f),0.0f} ,SpectrumPoint::CompareFreqLessThan); if(l>beginGet()) {--l;} SpectrumPoint* u=std::lower_bound(beginGet(),endGet(),(SpectrumPoint){float(f),0.0f} ,SpectrumPoint::CompareFreqLessThan); if(u==endGet()) {u=beginGet();} if(l==u) { if(u==endGet()) {return u->amp;} return l->amp; } double f_min=l->freq; double A_min=l->amp; double f_max=u->freq; double A_max=u->amp; double delta_f=f_max-f_min; double delta_A=A_max-A_min; return A_min + delta_A*(f-f_min)/delta_f; }

Answer 1

Lower bound: the initial greater-or-equal element.

Upper bound: first element that is strictly greater.

+- lb(2) == ub(2)       +- lb(6)        +- lb(8)
|        == begin()     |  == ub(6)     |   +- ub(8) == end()
V                       V               V   V
+---+---+---+---+---+---+---+---+---+---+---+
| 3 | 4 | 4 | 4 | 4 | 5 | 7 | 7 | 7 | 7 | 8 |
+---+---+---+---+---+---+---+---+---+---+---+
    ^               ^                       ^
    |               |                       |
    +- lb(4)        +- ub(4)                +- lb(9) == ub(9) == end()

    |- eq-range(4) -|

The half-open equal-range for n is [lb(n), ub(n)], as you can see.

Note that both limits provide appropriate insertion places for an element of the required value so that the ordering is preserved, but lower bound has the advantage of providing an iterator that really leads to the element if it already exists. 

As a result, you may create your own unique-membership or multiple-membership container by using lower bound on an ordered range.

void insert(Container & c, T const & t)
{
    auto it = std::lower_bound(c.begin(), c.end(), t);

    // if unique container:
    if (it != c.end() && *it == t) { /* error, element exists! */ return; }

    c.insert(it, t);
}