Reglamento Ambiental para Operaciones Hidrocarburíferas

Making successor regular allows us to pass through the same range more than once and to maintain more than one iterator into the range:

Note that Iterator and ForwardIterator differ only by an axiom; there are no new operations. In addition to successor, all the other functional procedures defined on refinements of the forward iterator concept introduced later in the chapter are regular. The regularity of successor allows us to implement find_adjacent_mismatch without saving the value before advancing:

template<typename I, typename R>

requires(Readable(I) && ForwardIterator(I) && Relation(R) && ValueType(I) == Domain(R)) I find_adjacent_mismatch forward(I f, I l, R r) { // Precondition: readable_bounded_range(f, l) if (f == l) return l; I t; do { t = f; f = successor(f);

} while (f != l && r(source(t), source(f))); return f;

}

Note that t points to the first element of this mismatched pair and could also be returned.

In Chapter 10 we show how to use concept dispatch to overload versions of an algorithm written for different iterator concepts. Suffixes such as _forward allow us to disambiguate the different versions.

The regularity of successor also allows us to implement the bisection algorithm for finding the partition point:

template<typename I, typename P>

requires(Readable(I) && ForwardIterator(I) && UnaryPredicate(P) && ValueType(I) == Domain(P)) I partition_point_n(I f, DistanceType(I) n, P p)

{

// Precondition: readable_counted_range(f, n) partitioned_n(f, n, p) while (!zero(n)) { DistanceType(I) h = half_nonnegative(n); I m = f + h; if (p(source(m))) { n = h; } else { n = n - successor(h); f = successor(m); } } return f; } Lemma 6.9.

Finding the partition point in a bounded range by bisection[8] _{requires first finding the size of the} range:

ForwardIterator(T)

Iterator(T)

regular_unary_function (successor)

[8] _{The bisection technique dates back at least as far as the proof of the Intermediate Value Theorem in Bolzano} [1817] and, independently, in Cauchy [1821]. While Bolzano and Cauchy used the technique for the most general case of continuous functions, Lagrange [1795] had previously used it to solve a particular problem of approximating a root of a polynomial. The first description of bisection for searching was John W. Mauchly's lecture "Sorting and collating" [Mauchly, 1946].

template<typename I, typename P>

requires(Readable(I) && ForwardIterator(I) && UnaryPredicate(P) && ValueType(I) == Domain(P)) I partition_point(I f, I l, P p)

{

// Precondition: readable_bounded_range(f, l) partitioned(f, l, p) return_partition_point_n(f, l - f, p);

}

The definition of partition point immediately leads to binary search algorithms on an r-increasing range for a weak ordering r. Any value a, whether or not it appears in the increasing range,

determines two iterators in the range called lower bound and upper bound. Informally, a lower bound is the first position where a value equivalent to a could occur in the increasing sequence. Similarly, an upper bound is the successor of the last position where a value equivalent to a could occur. Therefore elements equivalent to a appear only in the half-open range from lower bound to upper bound. For example, assuming total ordering, a sequence with lower bound l and upper bound u for the value a looks like this:

Note that any of the three regions may be empty.

Lemma 6.10.

lower_bound

a (x) ¬r(x, a) upper_bound_a (x) r(a, x)

That allows us to formally define lower bound and upper bound as the partition points of the corresponding predicates.

Lemma 6.11.

Implementing a function object corresponding to the predicate leads immediately to an algorithm for determining the lower bound:

template<typename R> requires(Relation(R)) struct lower_bound_predicate { typedef Domain(R) T; const T& a; R r;

lower_bound_predicate(const T& a, R r) : a(a), r(r) { } bool operator()(const T& x) { return !r(x, a); }

In an increasing range [f, l), for any value a of the value type of the range, the range is partitioned by the following two predicates:

};

template<typename I, typename R>

requires(Readable(I) && ForwardIterator(I) && Relation(R) && ValueType(I) == Domain(R)) I lower_bound_n(I f, DistanceType(I) n,

const ValueType(I)& a, R r) {

// Precondition: weak_ordering(r) increasing_counted_range(f, n, r) lower_bound_predicate<R> p(a, r);

return_partition_point_n(f, n, p); }

Similarly, for the upper bound:

template<typename R> requires(Relation(R)) struct upper_bound_predicate { typedef Domain(R) T; const T& a; R r;

upper_bound_predicate(const T& a, R r) : a(a), r(r) { } bool operator()(const T& x) { return r(a, x); }

};

template<typename I, typename R>

requires(Readable(I) && ForwardIterator(I) && Relation(R) && ValueType(I) == Domain(R)) I upper_bound_n(I f, DistanceType(I) n,

const ValueType(I)& a, R r) {

// Precondition: weak_ordering(r) increasing_counted_range(f, n, r) upper_bound_predicate<R> p(a, r);

return partition_point_n(f, n, p); }

Exercise 6.7.

Applying the predicate in the middle of the range ensures the optimal worst-case number of predicate applications in the partition-point algorithm. Any other choice would be defeated by an adversary who ensures that the larger subrange contains the partition point. Prior knowledge of the expected position of the partition point would lead to probing at that point.

partition_point_n applies the predicate log₂n + 1 times, since the length of the range is reduced

by a factor of 2 at each step. The algorithm performs a logarithmic number of iterator/integer additions.

Lemma 6.12.

Implement a procedure that returns both lower and upper bounds and does fewer comparisons than the sum of the comparisons that would be done by calling both lower_bound_n and upper_bound_n.[9]

[9] _{A similar STL function is called}

equal_range.

For a forward iterator, the total number of successor operations performed by the algorithm is less than or equal to the size of the range.

partition_point also calculates l – f, which, for forward iterators, adds another n calls of successor. It is worthwhile to use it on forward iterators, such as linked lists, whenever the predicate application is more expensive than calling successor.

Lemma 6.13.

Assuming that the expected distance to the partition point is equal to half the size of the range, partition_point is faster than find_if on finding the partition point for forward iterators whenever

Algorithms C++ Software Engineering Programming Alexander Stepanov Paul McJones Addison-Wesley Professional Elements of Programming