| /*-----------------------------------------------------------------------------+ |
| 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]} |
| //] |
| |
