Home Libraries People FAQ More

### Interval

Example interval shows some basic functionality of `intervals`.

• Different instances of `intervals` for integral (`int, Time`) and continuous types (```double, std::string```) are used.
• The examples uses open and closed intervals bounds.
• Some borderline functions calls on open interval borders are tested e.g.: ```interval<double>::rightopen(1/sqrt(2.0), sqrt(2.0)).contains(sqrt(2.0));```

```#include <iostream>
#include <string>
#include <math.h>

// Dynamically bounded intervals
#include <boost/icl/discrete_interval.hpp>
#include <boost/icl/continuous_interval.hpp>

// Statically bounded intervals
#include <boost/icl/right_open_interval.hpp>
#include <boost/icl/left_open_interval.hpp>
#include <boost/icl/closed_interval.hpp>
#include <boost/icl/open_interval.hpp>

#include "../toytime.hpp"
#include <boost/icl/rational.hpp>

using namespace std;
using namespace boost;
using namespace boost::icl;

int main()
{
cout << ">>Interval Container Library: Sample interval.cpp <<\n";
cout << "----------------------------------------------------\n";

// Class template discrete_interval can be used for discrete data types
// like integers, date and time and other types that have a least steppable
// unit.
discrete_interval<int>      int_interval
= construct<discrete_interval<int> >(3, 7, interval_bounds::closed());

// Class template continuous_interval can be used for continuous data types
// like double, boost::rational or strings.
continuous_interval<double> sqrt_interval
= construct<continuous_interval<double> >(1/sqrt(2.0), sqrt(2.0));
//interval_bounds::right_open() is default
continuous_interval<string> city_interval
= construct<continuous_interval<string> >("Barcelona", "Boston", interval_bounds::left_open());

discrete_interval<Time>     time_interval
= construct<discrete_interval<Time> >(Time(monday,8,30), Time(monday,17,20),
interval_bounds::open());

cout << "Dynamically bounded intervals:\n";
cout << "  discrete_interval<int>:    " << int_interval  << endl;
cout << "continuous_interval<double>: " << sqrt_interval << " does "
<< string(contains(sqrt_interval, sqrt(2.0))?"":"NOT")
<< " contain sqrt(2)" << endl;
cout << "continuous_interval<string>: " << city_interval << " does "
<< string(contains(city_interval,"Barcelona")?"":"NOT")
<< " contain 'Barcelona'" << endl;
cout << "continuous_interval<string>: " << city_interval << " does "
<< string(contains(city_interval, "Berlin")?"":"NOT")
<< " contain 'Berlin'" << endl;
cout << "  discrete_interval<Time>:   " << time_interval << "\n\n";

// There are statically bounded interval types with fixed interval borders
right_open_interval<string>   fix_interval1; // You will probably use one kind of static intervals
// right_open_intervals are recommended.
closed_interval<unsigned int> fix_interval2; // ... static closed, left_open and open intervals
left_open_interval<float>     fix_interval3; // are implemented for sake of completeness but
open_interval<short>          fix_interval4; // are of minor practical importance.

right_open_interval<rational<int> > range1(rational<int>(0,1),  rational<int>(2,3));
right_open_interval<rational<int> > range2(rational<int>(1,3),  rational<int>(1,1));

// This middle third of the unit interval [0,1)
cout << "Statically bounded interval:\n";
cout << "right_open_interval<rational<int>>: " << (range1 & range2) << endl;

return 0;
}

// Program output:

//>>Interval Container Library: Sample interval.cpp <<
//----------------------------------------------------
//Dynamically bounded intervals
//  discrete_interval<int>:    [3,7]
//continuous_interval<double>: [0.707107,1.41421) does NOT contain sqrt(2)
//continuous_interval<string>: (Barcelona,Boston] does NOT contain 'Barcelona'
//continuous_interval<string>: (Barcelona,Boston] does  contain 'Berlin'
//  discrete_interval<Time>:   (mon:08:30,mon:17:20)
//
//Statically bounded interval
//right_open_interval<rational<int>>: [1/3,2/3)

```