141 lines
6.6 KiB
C++
141 lines
6.6 KiB
C++
/*-----------------------------------------------------------------------------+
|
|
Interval Container Library
|
|
Author: Joachim Faulhaber
|
|
Copyright (c) 2007-2010: Joachim Faulhaber
|
|
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
|
|
+------------------------------------------------------------------------------+
|
|
Distributed under the Boost Software License, Version 1.0.
|
|
(See accompanying file LICENCE.txt or copy at
|
|
http://www.boost.org/LICENSE_1_0.txt)
|
|
+-----------------------------------------------------------------------------*/
|
|
/** Example dynamic_interval.cpp \file dynamic_interval.cpp
|
|
\brief Intervals with dynamic interval bounds that can be changed at runtime.
|
|
|
|
Intervals types with dynamic interval bounds can represent closed and
|
|
open interval borders. Interval borders are not static or fixed for
|
|
the type but may change due to computations in interval containers.
|
|
Dynamically bounded intervals are the library default for interval
|
|
parameters in interval containers.
|
|
|
|
\include dynamic_interval_/dynamic_interval.cpp
|
|
*/
|
|
//[example_dynamic_interval
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <math.h>
|
|
#include <boost/type_traits/is_same.hpp>
|
|
|
|
#include <boost/icl/interval_set.hpp>
|
|
#include <boost/icl/split_interval_set.hpp>
|
|
// Dynamically bounded intervals 'discrete_interval' and 'continuous_interval'
|
|
// are indirectly included via interval containers as library defaults.
|
|
#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";
|
|
|
|
// Dynamically bounded intervals are the library default for
|
|
// interval parameters in interval containers.
|
|
BOOST_STATIC_ASSERT((
|
|
boost::is_same< interval_set<int>::interval_type
|
|
, discrete_interval<int> >::value
|
|
));
|
|
|
|
|
|
BOOST_STATIC_ASSERT((
|
|
boost::is_same< interval_set<float>::interval_type
|
|
, continuous_interval<float> >::value
|
|
));
|
|
|
|
// As we can see the library default chooses the appropriate
|
|
// class template instance discrete_interval<T> or continuous_interval<T>
|
|
// dependent on the domain_type T. The library default for intervals
|
|
// is also available via the template 'interval':
|
|
BOOST_STATIC_ASSERT((
|
|
boost::is_same< interval<int>::type
|
|
, discrete_interval<int> >::value
|
|
));
|
|
|
|
BOOST_STATIC_ASSERT((
|
|
boost::is_same< interval<float>::type
|
|
, continuous_interval<float> >::value
|
|
));
|
|
|
|
// template interval also provides static functions for the four border types
|
|
|
|
interval<int>::type int_interval = interval<int>::closed(3, 7);
|
|
interval<double>::type sqrt_interval = interval<double>::right_open(1/sqrt(2.0), sqrt(2.0));
|
|
interval<string>::type city_interval = interval<string>::left_open("Barcelona", "Boston");
|
|
interval<Time>::type time_interval = interval<Time>::open(Time(monday,8,30), Time(monday,17,20));
|
|
|
|
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";
|
|
|
|
// Using dynamically bounded intervals allows to apply operations
|
|
// with intervals and also with elements on all interval containers
|
|
// including interval containers of continuous domain types:
|
|
|
|
interval<rational<int> >::type unit_interval
|
|
= interval<rational<int> >::right_open(rational<int>(0), rational<int>(1));
|
|
interval_set<rational<int> > unit_set(unit_interval);
|
|
interval_set<rational<int> > ratio_set(unit_set);
|
|
ratio_set -= rational<int>(1,3); // Subtract 1/3 from the set
|
|
|
|
cout << "----- Manipulation of single values in continuous sets ---------------------\n";
|
|
cout << "1/3 subtracted from [0..1) : " << ratio_set << endl;
|
|
cout << "The set does " << string(contains(ratio_set, rational<int>(1,3))?"":"NOT")
|
|
<< " contain '1/3'" << endl;
|
|
ratio_set ^= unit_set;
|
|
cout << "Flipping the holey set : " << ratio_set << endl;
|
|
cout << "yields the subtracted : 1/3\n\n";
|
|
|
|
// Of course we can use interval types that are different from the
|
|
// library default by explicit instantiation:
|
|
split_interval_set<int, std::less, closed_interval<Time> > intuitive_times;
|
|
// Interval set 'intuitive_times' uses statically bounded closed intervals
|
|
intuitive_times += closed_interval<Time>(Time(monday, 9,00), Time(monday, 10,59));
|
|
intuitive_times += closed_interval<Time>(Time(monday, 10,00), Time(monday, 11,59));
|
|
cout << "----- Here we are NOT using the library default for intervals --------------\n";
|
|
cout << intuitive_times << 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)
|
|
//
|
|
//----- Manipulation of single values in continuous sets ---------------------
|
|
//1/3 subtracted from [0..1) : {[0/1,1/3)(1/3,1/1)}
|
|
//The set does NOT contain '1/3'
|
|
//Flipping the holey set : {[1/3,1/3]}
|
|
//yields the subtracted : 1/3
|
|
//
|
|
//----- Here we are NOT using the library default for intervals --------------
|
|
//{[mon:09:00,mon:09:59][mon:10:00,mon:10:59][mon:11:00,mon:11:59]}
|
|
//]
|
|
|