EXT C++ Library - range

The ext::range utility class template describe a range of consecutive values through its lowest and highest (first and last) bounding value (inclusive).

---

Interface:

template <typename T>
class ext::range {
    public:
        typedef T       value_type;

    public:
        const T &       first;
        const T &       last;
        const T static  epsilon;

    public:
        range (const T &, const T &);
        range (const range &);
        range & operator = (range);

        T     size () const;

        bool contains (const T &) const;
        bool contains (const range &) const;
        bool intersects (const range &) const;
        bool touch (const range &) const;

        std::pair <range, range> split (const T &) const;
        std::pair <range, range> split (const range &) const;

        std::pair <range, range> cutoff (const T &) const;
        std::pair <range, range> cutoff (const range &) const;

        void extend (const T &);
        void extend (const range &);

        range & operator += (const range &);
};

template <typename T>
bool ext::operator == (const ext::range <T> &, const ext::range <T> &);
template <typename T>
bool ext::operator != (const ext::range <T> &, const ext::range <T> &);

template <typename T>
bool ext::operator  < (const ext::range <T> &, const ext::range <T> &);
template <typename T>
bool ext::operator <= (const ext::range <T> &, const ext::range <T> &);
template <typename T>
bool ext::operator >= (const ext::range <T> &, const ext::range <T> &);
template <typename T>
bool ext::operator  > (const ext::range <T> &, const ext::range <T> &);

template <typename T>
ext::range <T> ext::operator + (const ext::range <T> &, const ext::range <T> &);


• typename T
  ext::range::value_type
  The type of values that represent lower and upper inclusive boundary.
• ext::range::first
  A reference to a variable whose value is the lower boundary of the range.
• ext::range::last
  A reference to a variable whose value is the upper boundary of the range.
• ext::range::epsilon
  A static constant that defines (with questionable reliability) a single technological step of the underlying value type (T). For floating point types it is std::numeric_limits <T> ::epsilon (), for other types the value is hard-coded to 1.
  Note that this value is important only to cutoff and touch member functions.
• ext::range::range (const T &, const T &)
  The constructor. Initializes the first member with lower of the parameters (determined by std::min) and last with higher one (std::max).
• ext::range::size ()
  Returns the numeric span of the range, that is: last − first + epsilon.
• ext::range::contains (const T &)
  Determines if the range contains a value.
• ext::range::contains (const range &)
  Determines if the range contains a complete range described by parameter.
• ext::range::intersects (const range &)
  Determines if the range intersects with a second range. The ranges must share at least single value for this to evaluate to true, this means that there must be a value for which the contains member function for both ranges evaluate to true.
• ext::range::touch (const range &)
  Determines if the ranges touch. The ranges touch if they intersect, or when the difference of first of one and last of second is smaller or equal to epsilon.
  This effectively means that, although the ranges does not share a single common value, there is no value between the ranges, for which would the contains member function of both ranges have evaluated to true.
• ext::range::split (const range &)
  Returns a std::pair containing two ranges that represents both parts of the original range when divided by the parameter. If the parameter does not intersect the range, a std::out_of_range is thrown.
• ext::range::split (const T &)
  Constructs a temporary range whose both values are of the parameter's value and returns value of the overload of the split member function. See above.
• ext::range::cutoff (const range &)
  ext::range::cutoff (const T &)
  The cutoff member function is a variant of split but the resulting ranges will not include the bounding values.
• ext::range::extend (const range &)
  ext::range::extend (const T &)
  Updates one or both boundaries of a range so it contains the range or value passed by parameter.
• ext::range::operator += (const range &)
  The same as extend.

Examples:

#include <ext/c++>

ext::range <int> read_input () {
    int a, b;
    std::scanf ("%i %i", &a, &b);
    return ext::range <int> (a, b);
};

int main () {
    std::printf ("Range to poll: ");
    ext::range <int> r = read_input ();

    for (int i = r.first; i <= r.last; ++i) {
        std::printf ("%d [%d/%d]: %d\n",
                     i, i - r.first + 1, r.size (), /*poll*/ (i));
    };

    return 0;
};

Remarks

Note that the ext::range is intended to provide a common functionality that is often neccessary for common operations over ranges of integral or floating-point numbers. For complete (and mathematicaly correct) interval arithmetics see other libraries.

Note that the ext::range is implemented in terms of std::pair. In most cases you can assume the same behavior. Provided comparison operators (< and ==) only forward the calls to the appropriate std::pair operators.

The value of first and last members cannot be directly changed to avoid unintentional corruption of the range. Replace existing range with a new one instead.

Use the ext::range_set class template to handle non-continuous value ranges. That is ranges that need to be represented by multiple ext::range objects.

---

[index]