|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r51437 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/itl_xt boost/validate boost/validate/driver boost/validate/gentor boost/validate/laws boost/validate/loki_xt boost/validate/type boost/validate/validater libs/itl/example/boost_party libs/itl/example/interval libs/itl/example/itvset_shell libs/itl/example/man_power libs/itl/example/month_and_week_grid libs/itl/example/overlap_counter libs/itl/example/party libs/itl/example/user_groups libs/itl/test libs/itl/test/test_casual libs/itl/test/test_interval_map libs/itl/test/test_interval_map_mixed libs/itl/test/test_interval_set libs/itl/test/test_interval_set_laws libs/itl/test/test_interval_set_mixed libs/itl/test/test_itl_interval libs/itl/test/test_itl_map libs/itl/test/test_quantifier_itl_map libs/itl/test/test_quantifier_map libs/itl/test/test_separate_interval_set libs/itl/test/test_set_inerval_set libs/itl/test/test_set_itl_set libs/itl/test/test_split_interval_map libs/itl/test/test_split_interval_set libs/itl_xt/example libs/itl_xt/example/amount_cube libs/itl_xt/example/history libs/itl_xt/test libs/itl_xt/test/auto_itv_test libs/itl_xt/test/meta_functors libs/validate/example/labat_collector libs/validate/example/labat_itl_morphic libs/validate/example/labat_itl_order libs/validate/example/labat_itl_set libs/validate/example/labat_itv_map_groupig libs/validate/example/labat_itv_map_settic libs/validate/example/labat_itv_set libs/validate/example/labat_signed_quantifier libs/validate/example/labat_single libs/validate/example/labat_unsigned_quantifier libs/validate/example/labat_val_relations libs/validate/example/labat_val_setbase libs/validate/example/labatea libs/validate/src/gentor
From: afojgo_at_[hidden]
Date: 2009-02-24 14:48:22
Author: jofaber
Date: 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
New Revision: 51437
URL: http://svn.boost.org/trac/boost/changeset/51437
Log:
Reviewed documentation. Replaced tabs and headers. Stable {msvc-9.0, partly congcc-4.3-a7}
Text files modified:
sandbox/itl/boost/itl/detail/element_comparer.hpp | 150 ++++----
sandbox/itl/boost/itl/detail/relation_state.hpp | 28
sandbox/itl/boost/itl/detail/subset_comparer.hpp | 346 +++++++++++-----------
sandbox/itl/boost/itl/functors.hpp | 130 ++++----
sandbox/itl/boost/itl/interval.hpp | 312 ++++++++++----------
sandbox/itl/boost/itl/interval_base_map.hpp | 606 +++++++++++++++++++-------------------
sandbox/itl/boost/itl/interval_base_set.hpp | 270 ++++++++--------
sandbox/itl/boost/itl/interval_map.hpp | 80 ++--
sandbox/itl/boost/itl/interval_maps.hpp | 12
sandbox/itl/boost/itl/interval_set.hpp | 24
sandbox/itl/boost/itl/interval_set_algo.hpp | 84 ++--
sandbox/itl/boost/itl/interval_sets.hpp | 18
sandbox/itl/boost/itl/map.hpp | 322 ++++++++++----------
sandbox/itl/boost/itl/map_algo.hpp | 90 ++--
sandbox/itl/boost/itl/operators.hpp | 2
sandbox/itl/boost/itl/ptime.hpp | 2
sandbox/itl/boost/itl/rational.hpp | 2
sandbox/itl/boost/itl/separate_interval_set.hpp | 28
sandbox/itl/boost/itl/set.hpp | 154 +++++-----
sandbox/itl/boost/itl/set_algo.hpp | 12
sandbox/itl/boost/itl/split_interval_map.hpp | 96 +++---
sandbox/itl/boost/itl/split_interval_set.hpp | 32 +-
sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp | 10
sandbox/itl/boost/itl/type_traits/difference.hpp | 2
sandbox/itl/boost/itl/type_traits/has_inverse.hpp | 16
sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 280 +++++++++---------
sandbox/itl/boost/itl/type_traits/is_continuous.hpp | 48 +-
sandbox/itl/boost/itl/type_traits/is_interval_container.hpp | 16
sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp | 16
sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp | 16
sandbox/itl/boost/itl/type_traits/is_map.hpp | 16
sandbox/itl/boost/itl/type_traits/is_set.hpp | 16
sandbox/itl/boost/itl/type_traits/is_total.hpp | 16
sandbox/itl/boost/itl/type_traits/neutron.hpp | 8
sandbox/itl/boost/itl/type_traits/size.hpp | 8
sandbox/itl/boost/itl/type_traits/succ_pred.hpp | 8
sandbox/itl/boost/itl/type_traits/value_size.hpp | 2
sandbox/itl/boost/itl_xt/enum_bitset.hpp | 10
sandbox/itl/boost/itl_xt/episode_product.hpp | 10
sandbox/itl/boost/itl_xt/episode_set.hpp | 16
sandbox/itl/boost/itl_xt/fixtupelconst.hpp | 6
sandbox/itl/boost/itl_xt/gentorit.hpp | 6
sandbox/itl/boost/itl_xt/group_order.hpp | 10
sandbox/itl/boost/itl_xt/grouping.hpp | 6
sandbox/itl/boost/itl_xt/itvgentor.hpp | 8
sandbox/itl/boost/itl_xt/list.hpp | 10
sandbox/itl/boost/itl_xt/mapgentor.hpp | 6
sandbox/itl/boost/itl_xt/numbergentor.hpp | 8
sandbox/itl/boost/itl_xt/ordered_type.hpp | 10
sandbox/itl/boost/itl_xt/prefix_set.cpp | 10
sandbox/itl/boost/itl_xt/prefix_set.hpp | 10
sandbox/itl/boost/itl_xt/product_history.hpp | 6
sandbox/itl/boost/itl_xt/random.hpp | 6
sandbox/itl/boost/itl_xt/randomnumber.hpp | 6
sandbox/itl/boost/itl_xt/seqgentor.hpp | 8
sandbox/itl/boost/itl_xt/setgentor.hpp | 6
sandbox/itl/boost/itl_xt/statvardesct.hpp | 6
sandbox/itl/boost/itl_xt/string_list.cpp | 10
sandbox/itl/boost/itl_xt/string_list.hpp | 10
sandbox/itl/boost/itl_xt/string_map.hpp | 6
sandbox/itl/boost/itl_xt/string_set.hpp | 6
sandbox/itl/boost/itl_xt/string_sheet.cpp | 6
sandbox/itl/boost/itl_xt/string_sheet.hpp | 6
sandbox/itl/boost/itl_xt/stringpattern_set.hpp | 10
sandbox/itl/boost/itl_xt/tuple_computer.hpp | 10
sandbox/itl/boost/itl_xt/typed_episode.hpp | 10
sandbox/itl/boost/itl_xt/var_permutation.hpp | 6
sandbox/itl/boost/itl_xt/var_tuple.hpp | 10
sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp | 6
sandbox/itl/boost/itl_xt/var_tuple_order.hpp | 10
sandbox/itl/boost/validate/driver/collector_driver.hpp | 10
sandbox/itl/boost/validate/driver/itl_driver.hpp | 14
sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp | 26
sandbox/itl/boost/validate/driver/itl_order_driver.hpp | 10
sandbox/itl/boost/validate/driver/itl_set_driver.hpp | 10
sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp | 60 +-
sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp | 10
sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp | 10
sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 8
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 8
sandbox/itl/boost/validate/gentor/rangegentor.hpp | 8
sandbox/itl/boost/validate/itl_relations_validater.hpp | 58 +-
sandbox/itl/boost/validate/laws/element_order.hpp | 92 +++---
sandbox/itl/boost/validate/laws/induced_relation.hpp | 28
sandbox/itl/boost/validate/laws/inversion_laws.hpp | 42 +-
sandbox/itl/boost/validate/laws/map_laws.hpp | 38 +-
sandbox/itl/boost/validate/laws/monoid.hpp | 8
sandbox/itl/boost/validate/laws/order.hpp | 12
sandbox/itl/boost/validate/laws/pushouts.hpp | 8
sandbox/itl/boost/validate/laws/set_laws.hpp | 12
sandbox/itl/boost/validate/laws/subset_order.hpp | 96 +++---
sandbox/itl/boost/validate/laws/symmetric_difference.hpp | 12
sandbox/itl/boost/validate/loki_xt/Tuple.h | 8
sandbox/itl/boost/validate/loki_xt/TupleGentor.h | 8
sandbox/itl/boost/validate/loki_xt/TypelistGentor.h | 8
sandbox/itl/boost/validate/type/nat.hpp | 76 ++--
sandbox/itl/boost/validate/utility.hpp | 8
sandbox/itl/boost/validate/validater/algebra_validater.hpp | 28
sandbox/itl/boost/validate/validater/collector_validater.hpp | 32 +-
sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp | 8
sandbox/itl/boost/validate/validater/itl_induced_relations.hpp | 10
sandbox/itl/boost/validate/validater/itl_order_validater.hpp | 12
sandbox/itl/boost/validate/validater/itl_set_validater.hpp | 32 +-
sandbox/itl/boost/validate/validater/law_validater.hpp | 8
sandbox/itl/boost/validate/validater/partial_order_validater.hpp | 10
sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp | 64 ++--
sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp | 8
sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp | 28
sandbox/itl/libs/itl/example/boost_party/boost_party.cpp | 14
sandbox/itl/libs/itl/example/interval/interval.cpp | 2
sandbox/itl/libs/itl/example/interval/vc9_interval.vcproj | 4
sandbox/itl/libs/itl/example/itvset_shell/itvset_shell.cpp | 4
sandbox/itl/libs/itl/example/man_power/man_power.cpp | 8
sandbox/itl/libs/itl/example/month_and_week_grid/month_and_week_grid.cpp | 8
sandbox/itl/libs/itl/example/overlap_counter/overlap_counter.cpp | 8
sandbox/itl/libs/itl/example/party/party.cpp | 8
sandbox/itl/libs/itl/example/user_groups/user_groups.cpp | 8
sandbox/itl/libs/itl/test/test_casual/test_casual.cpp | 78 ++--
sandbox/itl/libs/itl/test/test_interval_map/test_interval_map.cpp | 8
sandbox/itl/libs/itl/test/test_interval_map/test_interval_map_shared.cpp | 8
sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp | 90 ++--
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 324 ++++++++++----------
sandbox/itl/libs/itl/test/test_interval_set/test_interval_set.cpp | 8
sandbox/itl/libs/itl/test/test_interval_set/test_interval_set_shared.cpp | 8
sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws.cpp | 8
sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws_shared.cpp | 2
sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp | 144 ++++----
sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp | 134 ++++----
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 222 +++++++-------
sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp | 44 +-
sandbox/itl/libs/itl/test/test_itl_map.hpp | 30
sandbox/itl/libs/itl/test/test_itl_map/test_itl_map.cpp | 8
sandbox/itl/libs/itl/test/test_itl_map/test_itl_map_shared.cpp | 2
sandbox/itl/libs/itl/test/test_laws.hpp | 256 ++++++++--------
sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp | 240 +++++++-------
sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map.cpp | 8
sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map_shared.cpp | 2
sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map.cpp | 8
sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp | 2
sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 144 ++++----
sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set.cpp | 8
sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set_shared.cpp | 8
sandbox/itl/libs/itl/test/test_set_inerval_set/test_set_interval_set.cpp | 8
sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp | 88 ++--
sandbox/itl/libs/itl/test/test_set_itl_set.hpp | 148 ++++----
sandbox/itl/libs/itl/test/test_set_itl_set/test_set_itl_set.cpp | 8
sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map.cpp | 8
sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map_shared.cpp | 8
sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set.cpp | 8
sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set_shared.cpp | 8
sandbox/itl/libs/itl/test/test_type_lists.hpp | 8
sandbox/itl/libs/itl/test/test_value_maker.hpp | 116 +++---
sandbox/itl/libs/itl_xt/example/amount_cube/amount_cube.cpp | 8
sandbox/itl/libs/itl_xt/example/history/history.cpp | 10
sandbox/itl/libs/itl_xt/example/toytime.h | 6
sandbox/itl/libs/itl_xt/test/auto_itv_test/auto_itv_test.cpp | 12
sandbox/itl/libs/itl_xt/test/itvsettester.h | 6
sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp | 194 ++++++------
sandbox/itl/libs/validate/example/labat_collector/labat_collector.cpp | 10
sandbox/itl/libs/validate/example/labat_itl_morphic/labat_itl_morphic.cpp | 10
sandbox/itl/libs/validate/example/labat_itl_order/labat_itl_order.cpp | 10
sandbox/itl/libs/validate/example/labat_itl_set/labat_itl_set.cpp | 10
sandbox/itl/libs/validate/example/labat_itv_map_groupig/labat_itv_map_groupig.cpp | 10
sandbox/itl/libs/validate/example/labat_itv_map_settic/labat_itv_map_settic.cpp | 10
sandbox/itl/libs/validate/example/labat_itv_set/labat_itv_set.cpp | 10
sandbox/itl/libs/validate/example/labat_signed_quantifier/labat_signed_quantifier.cpp | 10
sandbox/itl/libs/validate/example/labat_single/labat_single.cpp | 62 ++--
sandbox/itl/libs/validate/example/labat_unsigned_quantifier/labat_unsigned_quantifier.cpp | 10
sandbox/itl/libs/validate/example/labat_val_relations/labat_val_relations.cpp | 10
sandbox/itl/libs/validate/example/labat_val_setbase/labat_val_setbase.cpp | 10
sandbox/itl/libs/validate/example/labatea/labatea.cpp | 82 ++--
sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp | 8
172 files changed, 3622 insertions(+), 3618 deletions(-)
Modified: sandbox/itl/boost/itl/detail/element_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_comparer.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -27,59 +27,59 @@
typedef typename RightT::const_iterator RightIterT;
element_comparer(const LeftT& left,
- const RightT& right,
- const LeftIterT& left_end,
- const RightIterT& right_end)
+ const RightT& right,
+ const LeftIterT& left_end,
+ const RightIterT& right_end)
: _left(left), _right(right),
- _left_end(left_end), _right_end(right_end),
- _compare_codomain(false), _result(equal)
+ _left_end(left_end), _right_end(right_end),
+ _compare_codomain(false), _result(equal)
{}
enum{nextboth, nextleft, nextright, stop};
- enum
- {
- less = comparison::less,
- equal = comparison::equal,
- greater = comparison::greater
- };
+ enum
+ {
+ less = comparison::less,
+ equal = comparison::equal,
+ greater = comparison::greater
+ };
- void set_compare_codomain(bool truth=true)
- { _compare_codomain = truth; }
+ void set_compare_codomain(bool truth=true)
+ { _compare_codomain = truth; }
- bool compare_codomain()const { return _compare_codomain; }
+ bool compare_codomain()const { return _compare_codomain; }
int result()const{ return _result; }
- bool covalues_are_equal(LeftIterT& left, RightIterT& right)
- {
- if(LeftT::codomain_value(left) < RightT::codomain_value(right))
- _result = less;
- if(RightT::codomain_value(right) < LeftT::codomain_value(left))
- _result = greater;
- return _result == equal;
- }
+ bool covalues_are_equal(LeftIterT& left, RightIterT& right)
+ {
+ if(LeftT::codomain_value(left) < RightT::codomain_value(right))
+ _result = less;
+ if(RightT::codomain_value(right) < LeftT::codomain_value(left))
+ _result = greater;
+ return _result == equal;
+ }
int proceed(LeftIterT& left, RightIterT& right)
{
- if(LeftT::key_value(left).upper_less(RightT::key_value(right)))
+ if(LeftT::key_value(left).upper_less(RightT::key_value(right)))
{
_prior_left = left;
++left;
return nextleft;
}
- else if(RightT::key_value(right).upper_less(LeftT::key_value(left)))
+ else if(RightT::key_value(right).upper_less(LeftT::key_value(left)))
{
_prior_right = right;
++right;
return nextright;
}
- else
- {
+ else
+ {
++left;
++right;
return nextboth;
- }
+ }
}
int next_both(LeftIterT& left, RightIterT& right)
@@ -92,50 +92,50 @@
// left != _left_end
if(right == _right_end)
- {
- _result = greater;
+ {
+ _result = greater;
return stop;
- }
+ }
- // The starting intervals have to begin equally
- if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
- { // left: same A... = sameA...
- // right:same B.. = sameB...
- _result = less;
- return stop;
- }
-
- if(LeftT::key_value(right).lower_less(RightT::key_value(left)))
- { // left: same B.. = sameB...
- // right:same A... = sameA...
- _result = greater;
- return stop;
- }
+ // The starting intervals have to begin equally
+ if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
+ { // left: same A... = sameA...
+ // right:same B.. = sameB...
+ _result = less;
+ return stop;
+ }
+
+ if(LeftT::key_value(right).lower_less(RightT::key_value(left)))
+ { // left: same B.. = sameB...
+ // right:same A... = sameA...
+ _result = greater;
+ return stop;
+ }
if(compare_codomain() && !covalues_are_equal(left, right))
- return stop;
+ return stop;
- return proceed(left, right);
+ return proceed(left, right);
}
int next_left(LeftIterT& left, RightIterT& right)
{
if(left == _left_end)
- { // left: same
- // right:sameA...
- _result = less;
+ { // left: same
+ // right:sameA...
+ _result = less;
return stop;
- }
+ }
if(!LeftT::key_value(_prior_left).touches(LeftT::key_value(left)))
- { // left: same B = sameB...
- // right:sameA = sameA...
- _result = greater;
+ { // left: same B = sameB...
+ // right:sameA = sameA...
+ _result = greater;
return stop;
- }
+ }
if(compare_codomain() && !covalues_are_equal(left, right))
- return stop;
+ return stop;
return proceed(left, right);
}
@@ -143,32 +143,32 @@
int next_right(LeftIterT& left, RightIterT& right)
{
if(right == _right_end)
- { // left: sameA...
- // right:same
- _result = greater;
+ { // left: sameA...
+ // right:same
+ _result = greater;
return stop;
- }
+ }
if(!RightT::key_value(_prior_right).touches(RightT::key_value(right)))
- {
- // left: sameA... = sameA...
- // right:same B.. = sameB...
- _result = less;
+ {
+ // left: sameA... = sameA...
+ // right:same B.. = sameB...
+ _result = less;
return stop;
- }
+ }
if(compare_codomain() && !covalues_are_equal(left, right))
- return stop;
+ return stop;
return proceed(left, right);
}
private:
- const LeftT& _left;
- const RightT& _right;
+ const LeftT& _left;
+ const RightT& _right;
LeftIterT _left_end;
RightIterT _right_end;
- bool _compare_codomain;
+ bool _compare_codomain;
LeftIterT _prior_left;
RightIterT _prior_right;
int _result;
@@ -179,17 +179,17 @@
template<class LeftT, class RightT>
int element_compare
(
- const LeftT& left, //sub
- const RightT& right, //super
- typename LeftT::const_iterator left_begin,
- typename LeftT::const_iterator left_end,
- typename RightT::const_iterator right_begin,
- typename RightT::const_iterator right_end
+ const LeftT& left, //sub
+ const RightT& right, //super
+ typename LeftT::const_iterator left_begin,
+ typename LeftT::const_iterator left_end,
+ typename RightT::const_iterator right_begin,
+ typename RightT::const_iterator right_end
)
{
typedef element_comparer<LeftT,RightT> Step;
Step step(left, right, left_end, right_end);
- step.set_compare_codomain(is_map<LeftT>::value && is_map<RightT>::value);
+ step.set_compare_codomain(is_map<LeftT>::value && is_map<RightT>::value);
typename LeftT::const_iterator left_ = left_begin;
typename RightT::const_iterator right_ = right_begin;
Modified: sandbox/itl/boost/itl/detail/relation_state.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/relation_state.hpp (original)
+++ sandbox/itl/boost/itl/detail/relation_state.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -14,20 +14,20 @@
namespace boost{namespace itl
{
- namespace comparison
- {
- static const int less = -1;
- static const int equal = 0;
- static const int greater = 1;
- }
-
- namespace inclusion
- {
- static const int unrelated = 0;
- static const int subset = 1;
- static const int superset = 2;
- static const int equal = 3;
- }
+ namespace comparison
+ {
+ static const int less = -1;
+ static const int equal = 0;
+ static const int greater = 1;
+ }
+
+ namespace inclusion
+ {
+ static const int unrelated = 0;
+ static const int subset = 1;
+ static const int superset = 2;
+ static const int equal = 3;
+ }
}} // namespace itl boost
Modified: sandbox/itl/boost/itl/detail/subset_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/subset_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/subset_comparer.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -28,181 +28,181 @@
typedef typename RightT::const_iterator RightIterT;
subset_comparer(const LeftT& left,
- const RightT& right,
- const LeftIterT& left_end,
- const RightIterT& right_end)
+ const RightT& right,
+ const LeftIterT& left_end,
+ const RightIterT& right_end)
: _left(left), _right(right),
- _left_end(left_end), _right_end(right_end),
- _compare_codomain(false), _result(equal)
+ _left_end(left_end), _right_end(right_end),
+ _compare_codomain(false), _result(equal)
{}
enum{nextboth, nextleft, nextright, stop};
- enum
- {
- unrelated = inclusion::unrelated,
- subset = inclusion::subset, // left is_subset_of right
- superset = inclusion::superset, // left is_superset_of right
- equal = inclusion::equal // equal = subset | superset
- };
+ enum
+ {
+ unrelated = inclusion::unrelated,
+ subset = inclusion::subset, // left is_subset_of right
+ superset = inclusion::superset, // left is_superset_of right
+ equal = inclusion::equal // equal = subset | superset
+ };
- void set_compare_codomain(bool truth=true)
- { _compare_codomain = truth; }
+ void set_compare_codomain(bool truth=true)
+ { _compare_codomain = truth; }
- bool compare_codomain()const { return _compare_codomain; }
+ bool compare_codomain()const { return _compare_codomain; }
int result()const{ return _result; }
- bool covalues_are_equal(LeftIterT& left, RightIterT& right)
- {
- if(LeftT::codomain_value(left) == RightT::codomain_value(right))
- return true;
-
- _result = unrelated;
- return false;
- }
+ bool covalues_are_equal(LeftIterT& left, RightIterT& right)
+ {
+ if(LeftT::codomain_value(left) == RightT::codomain_value(right))
+ return true;
+
+ _result = unrelated;
+ return false;
+ }
- int restrict_result(int state) { return _result &= state; }
+ int restrict_result(int state) { return _result &= state; }
int proceed(LeftIterT& left, RightIterT& right)
{
- if(LeftT::key_value(left).upper_less(RightT::key_value(right)))
- { // left ..)
- // right .....)
- _prior_left = left;
- ++left;
- return nextleft;
- }
- else if(RightT::key_value(right).upper_less(LeftT::key_value(left)))
- { // left .....)
- // right ..)
- _prior_right = right;
+ if(LeftT::key_value(left).upper_less(RightT::key_value(right)))
+ { // left ..)
+ // right .....)
+ _prior_left = left;
+ ++left;
+ return nextleft;
+ }
+ else if(RightT::key_value(right).upper_less(LeftT::key_value(left)))
+ { // left .....)
+ // right ..)
+ _prior_right = right;
++right;
return nextright;
}
- else//LeftT::key_value(left).upper_equal(RightT::key_value(right))
- { // left ..)
- // right ..)
+ else//LeftT::key_value(left).upper_equal(RightT::key_value(right))
+ { // left ..)
+ // right ..)
++left;
++right;
return nextboth;
- }
+ }
}
int next_both(LeftIterT& left, RightIterT& right)
{
if(left == _left_end && right == _right_end)
return stop;
- else if(left == _left_end)
- { // left: ....end left could be subset
- // right:....[..
- restrict_result(subset);
- return stop;
- }
+ else if(left == _left_end)
+ { // left: ....end left could be subset
+ // right:....[..
+ restrict_result(subset);
+ return stop;
+ }
else if(right == _right_end)
- { // left: ....[.. left could be superset
- // right:....end
- restrict_result(superset);
- return stop;
- }
- else if(LeftT::key_value(left).exclusive_less(RightT::key_value(right)))
- { // left: [..) . . .[---) left could be superset
- // right: [..).... if [---) exists
- restrict_result(superset);
- if(unrelated == _result)
- return stop;
- else
- {
- LeftIterT joint_ = _left.lower_bound(RightT::key_value(right));
- if(joint_ == _left.end())
- {
- _result = unrelated;
- return stop;
- }
- else
- {
- left = joint_;
- return nextboth;
- }
- }
- }
- else if(RightT::key_value(right).exclusive_less(LeftT::key_value(left)))
- { // left: [.. left could be subset
- // right:....) . . .[---) if [---) exists
- restrict_result(subset);
- if(unrelated == _result)
- return stop;
- else
- {
- RightIterT joint_ = _right.lower_bound(LeftT::key_value(left));
- if(joint_ == _right.end())
- {
- _result = unrelated;
- return stop;
- }
- else
- {
- right = joint_;
- return nextboth;
- }
- }
- }
+ { // left: ....[.. left could be superset
+ // right:....end
+ restrict_result(superset);
+ return stop;
+ }
+ else if(LeftT::key_value(left).exclusive_less(RightT::key_value(right)))
+ { // left: [..) . . .[---) left could be superset
+ // right: [..).... if [---) exists
+ restrict_result(superset);
+ if(unrelated == _result)
+ return stop;
+ else
+ {
+ LeftIterT joint_ = _left.lower_bound(RightT::key_value(right));
+ if(joint_ == _left.end())
+ {
+ _result = unrelated;
+ return stop;
+ }
+ else
+ {
+ left = joint_;
+ return nextboth;
+ }
+ }
+ }
+ else if(RightT::key_value(right).exclusive_less(LeftT::key_value(left)))
+ { // left: [.. left could be subset
+ // right:....) . . .[---) if [---) exists
+ restrict_result(subset);
+ if(unrelated == _result)
+ return stop;
+ else
+ {
+ RightIterT joint_ = _right.lower_bound(LeftT::key_value(left));
+ if(joint_ == _right.end())
+ {
+ _result = unrelated;
+ return stop;
+ }
+ else
+ {
+ right = joint_;
+ return nextboth;
+ }
+ }
+ }
- // left and right have intervals with nonempty intersection:
+ // left and right have intervals with nonempty intersection:
if(compare_codomain() && !covalues_are_equal(left, right))
- return stop;
+ return stop;
- // examine left borders only. Right borders are checked in proceed
- if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
- { // left: ....[... left could be superset
- // right:.... [..
- if(unrelated == restrict_result(superset))
- return stop;
- }
- else if(LeftT::key_value(right).lower_less(RightT::key_value(left)))
- { // left: .... [.. left can be subset
- // right:....[...
- if(unrelated == restrict_result(subset))
- return stop;
- }
- //else LeftT::key_value(right).lower_equal(RightT::key_value(left))
- // left: ....[.. both can be equal
- // right:....[..
- // nothing to do: proceed
+ // examine left borders only. Right borders are checked in proceed
+ if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
+ { // left: ....[... left could be superset
+ // right:.... [..
+ if(unrelated == restrict_result(superset))
+ return stop;
+ }
+ else if(LeftT::key_value(right).lower_less(RightT::key_value(left)))
+ { // left: .... [.. left can be subset
+ // right:....[...
+ if(unrelated == restrict_result(subset))
+ return stop;
+ }
+ //else LeftT::key_value(right).lower_equal(RightT::key_value(left))
+ // left: ....[.. both can be equal
+ // right:....[..
+ // nothing to do: proceed
- return proceed(left, right);
+ return proceed(left, right);
}
int next_left(LeftIterT& left, RightIterT& right)
{
if(left == _left_end)
- { // left: ..)end left could be subset
- // right:......)
- restrict_result(subset);
- return stop;
- }
+ { // left: ..)end left could be subset
+ // right:......)
+ restrict_result(subset);
+ return stop;
+ }
else if(!LeftT::key_value(_prior_left).touches(LeftT::key_value(left)))
- { // left: ..) [..
- // right:.........)
- if(RightT::key_value(right).lower_less(LeftT::key_value(left)))
- { // ..) [.. left could be subset
- // ..........)
- if(unrelated == restrict_result(subset))
- return stop;
- }
- //else ..) [...
- // [..
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
- && !covalues_are_equal(left, right))
- return stop;
- }
- else
- { // left: ..)[.. left could be subset
- // right:.......)
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
- && !covalues_are_equal(left, right))
- return stop;
- }
+ { // left: ..) [..
+ // right:.........)
+ if(RightT::key_value(right).lower_less(LeftT::key_value(left)))
+ { // ..) [.. left could be subset
+ // ..........)
+ if(unrelated == restrict_result(subset))
+ return stop;
+ }
+ //else ..) [...
+ // [..
+ if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
+ && !covalues_are_equal(left, right))
+ return stop;
+ }
+ else
+ { // left: ..)[.. left could be subset
+ // right:.......)
+ if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
+ && !covalues_are_equal(left, right))
+ return stop;
+ }
return proceed(left, right);
}
@@ -211,42 +211,42 @@
int next_right(LeftIterT& left, RightIterT& right)
{
if(right == _right_end)
- { // left: ......) left could be superset
- // right:..)end
- restrict_result(superset);
- return stop;
- }
+ { // left: ......) left could be superset
+ // right:..)end
+ restrict_result(superset);
+ return stop;
+ }
else if(!RightT::key_value(_prior_right).touches(RightT::key_value(right)))
- { // left: .........)
- // right:..) [..
- if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
- { // [....) left could be superset
- // ..) [..
- if(unrelated == restrict_result(superset))
- return stop;
- }
- //else [....)
- // ..) [..
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
- && !covalues_are_equal(left, right))
- return stop;
- }
- else
- {
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
- && !covalues_are_equal(left, right))
- return stop;
- }
+ { // left: .........)
+ // right:..) [..
+ if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
+ { // [....) left could be superset
+ // ..) [..
+ if(unrelated == restrict_result(superset))
+ return stop;
+ }
+ //else [....)
+ // ..) [..
+ if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
+ && !covalues_are_equal(left, right))
+ return stop;
+ }
+ else
+ {
+ if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right))
+ && !covalues_are_equal(left, right))
+ return stop;
+ }
return proceed(left, right);
}
private:
- const LeftT& _left;
- const RightT& _right;
+ const LeftT& _left;
+ const RightT& _right;
LeftIterT _left_end;
RightIterT _right_end;
- bool _compare_codomain;
+ bool _compare_codomain;
LeftIterT _prior_left;
RightIterT _prior_right;
int _result;
@@ -262,17 +262,17 @@
template<class LeftT, class RightT>
int subset_compare
(
- const LeftT& left, //sub
- const RightT& right, //super
- typename LeftT::const_iterator left_begin,
- typename LeftT::const_iterator left_end,
- typename RightT::const_iterator right_begin,
- typename RightT::const_iterator right_end
+ const LeftT& left, //sub
+ const RightT& right, //super
+ typename LeftT::const_iterator left_begin,
+ typename LeftT::const_iterator left_end,
+ typename RightT::const_iterator right_begin,
+ typename RightT::const_iterator right_end
)
{
typedef subset_comparer<LeftT,RightT> Step;
Step step(left, right, left_end, right_end);
- step.set_compare_codomain(is_map<LeftT>::value && is_map<RightT>::value);
+ step.set_compare_codomain(is_map<LeftT>::value && is_map<RightT>::value);
typename LeftT::const_iterator left_ = left_begin;
typename RightT::const_iterator right_ = right_begin;
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -18,14 +18,14 @@
template <typename Type> struct neutron_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
// ------------------------------------------------------------------------
template <typename Type> struct unon_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type neutron() { return boost::itl::unon<Type>::value(); }
+ static Type neutron() { return boost::itl::unon<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -33,7 +33,7 @@
: public neutron_based_inplace_combine<Type>
{
void operator()(Type& object, const Type& operand)const{}
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -49,7 +49,7 @@
if(object == operand)
object = Type();
}
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -77,7 +77,7 @@
void operator()(Type& object, const Type& operand)const
{ object -= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -104,7 +104,7 @@
void operator()(Type& object, const Type& operand)const
{ object &= ~operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -131,7 +131,7 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -155,7 +155,7 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -168,7 +168,7 @@
void operator()(Type& object, const Type& operand)const
{ insert(object,operand); }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -181,7 +181,7 @@
void operator()(Type& object, const Type& operand)const
{ erase(object,operand); }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -194,7 +194,7 @@
void operator()(Type& object, const Type& operand)const
{ object *= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -207,7 +207,7 @@
void operator()(Type& object, const Type& operand)const
{ object /= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -223,7 +223,7 @@
object = operand;
}
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
@@ -239,63 +239,63 @@
object = operand;
}
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
inline std::string unary_template_to_string<inplace_min>::apply() { return "min="; }
- //--------------------------------------------------------------------------
- // Inverse functor
- template<class Functor> struct inverse;
-
- template<class Type>
- struct inverse<itl::inplace_plus<Type> >
- { typedef itl::inplace_minus<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_minus<Type> >
- { typedef itl::inplace_plus<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_bit_add<Type> >
- { typedef itl::inplace_bit_subtract<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_bit_subtract<Type> >
- { typedef itl::inplace_bit_add<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_et<Type> >
- { typedef itl::inplace_caret<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_caret<Type> >
- { typedef itl::inplace_et<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_bit_and<Type> >
- { typedef itl::inplace_bit_xor<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_bit_xor<Type> >
- { typedef itl::inplace_bit_and<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_star<Type> >
- { typedef itl::inplace_slash<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_slash<Type> >
- { typedef itl::inplace_star<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_max<Type> >
- { typedef itl::inplace_min<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_min<Type> >
- { typedef itl::inplace_max<Type> type; };
+ //--------------------------------------------------------------------------
+ // Inverse functor
+ template<class Functor> struct inverse;
+
+ template<class Type>
+ struct inverse<itl::inplace_plus<Type> >
+ { typedef itl::inplace_minus<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_minus<Type> >
+ { typedef itl::inplace_plus<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_bit_add<Type> >
+ { typedef itl::inplace_bit_subtract<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_bit_subtract<Type> >
+ { typedef itl::inplace_bit_add<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_et<Type> >
+ { typedef itl::inplace_caret<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_caret<Type> >
+ { typedef itl::inplace_et<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_bit_and<Type> >
+ { typedef itl::inplace_bit_xor<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_bit_xor<Type> >
+ { typedef itl::inplace_bit_and<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_star<Type> >
+ { typedef itl::inplace_slash<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_slash<Type> >
+ { typedef itl::inplace_star<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_max<Type> >
+ { typedef itl::inplace_min<Type> type; };
+
+ template<class Type>
+ struct inverse<itl::inplace_min<Type> >
+ { typedef itl::inplace_max<Type> type; };
}} // namespace itl boost
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -59,7 +59,7 @@
/** A class template for intervals */
template <class DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
#ifdef USE_CONCEPTS
- requires std::LessThanComparable<DomainT>
+ requires std::LessThanComparable<DomainT>
#endif
class interval
{
@@ -72,14 +72,14 @@
typedef DomainT element_type;
typedef type segment_type;
- typedef DomainT key_type;
- typedef DomainT data_type;
- typedef DomainT value_type;
+ typedef DomainT key_type;
+ typedef DomainT data_type;
+ typedef DomainT value_type;
typedef type interval_type;
- /// Compare order on the data
+ /// Compare order on the data
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef domain_compare key_compare;
+ typedef domain_compare key_compare;
/// The difference type of an interval which is sometimes different form the domain_type
typedef typename itl::difference<DomainT>::type difference_type;
@@ -88,51 +88,51 @@
typedef typename itl::size<DomainT>::type size_type;
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/** Default constructor; yields an empty interval <tt>[1,0]</tt> */
interval() : _lwb(unon<DomainT>::value()), _upb(neutron<DomainT>::value()),
- _boundtype(itl::closed_bounded) {}
+ _boundtype(itl::closed_bounded) {}
//NOTE: Compiler generated copy constructor is used
/** Constructor for a closed singleton interval <tt>[val,val]</tt> */
explicit interval(const DomainT& val) :
- _lwb(val), _upb(val), _boundtype(itl::closed_bounded) {}
+ _lwb(val), _upb(val), _boundtype(itl::closed_bounded) {}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
- interval(const DomainT& low, const DomainT& up, itl::bound_type bounds = itl::closed_bounded) :
+ interval(const DomainT& low, const DomainT& up, itl::bound_type bounds = itl::closed_bounded) :
_lwb(low), _upb(up), _boundtype(bounds) {}
- /** Closed interval <tt>[low,up]</tt> */
- static interval closed(const DomainT& low, const DomainT& up)
- { return interval(low, up, itl::closed_bounded); }
-
- /** Rightopen interval <tt>[low,up)</tt> */
- static interval rightopen(const DomainT& low, const DomainT& up)
- { return interval(low, up, right_open); }
-
- /** Leftopen interval <tt>(low,up]</tt> */
- static interval leftopen(const DomainT& low, const DomainT& up)
- { return interval(low, up, left_open); }
-
- /** Open interval <tt>(low,up)</tt> */
- static interval open(const DomainT& low, const DomainT& up)
- { return interval(low, up, itl::open_bounded); }
+ /** Closed interval <tt>[low,up]</tt> */
+ static interval closed(const DomainT& low, const DomainT& up)
+ { return interval(low, up, itl::closed_bounded); }
+
+ /** Rightopen interval <tt>[low,up)</tt> */
+ static interval rightopen(const DomainT& low, const DomainT& up)
+ { return interval(low, up, right_open); }
+
+ /** Leftopen interval <tt>(low,up]</tt> */
+ static interval leftopen(const DomainT& low, const DomainT& up)
+ { return interval(low, up, left_open); }
+
+ /** Open interval <tt>(low,up)</tt> */
+ static interval open(const DomainT& low, const DomainT& up)
+ { return interval(low, up, itl::open_bounded); }
//NOTE: Compiler generated assignment operator = used
- //==========================================================================
- //= Emptieness, containment
- //==========================================================================
+ //==========================================================================
+ //= Emptieness, containment
+ //==========================================================================
/** Is the interval empty? */
bool empty()const;
/** Set the interval empty */
void clear()
- { set_lwb(unon<DomainT>::value()); set_upb(neutron<DomainT>::value());
- _boundtype=itl::closed_bounded; }
+ { set_lwb(unon<DomainT>::value()); set_upb(neutron<DomainT>::value());
+ _boundtype=itl::closed_bounded; }
/** Does the interval contain <tt>x</tt>? */
bool contains(const DomainT& x)const;
@@ -146,9 +146,9 @@
bool is_disjoint(const interval& x2)const
{ return exclusive_less(x2) || x2.exclusive_less(*this); }
- //==========================================================================
- //= Size
- //==========================================================================
+ //==========================================================================
+ //= Size
+ //==========================================================================
/** Cardinality of the interval: The number of elements */
size_type cardinality()const;
@@ -158,9 +158,9 @@
/** Size of the interval */
size_type size()const { return cardinality(); }
- //==========================================================================
- //= Range
- //==========================================================================
+ //==========================================================================
+ //= Range
+ //==========================================================================
/** Lower bound of the interval */
DomainT lower()const { return _lwb; }
/** Upper bound of the interval */
@@ -171,23 +171,23 @@
/** Last (largest) element of the interval */
DomainT last()const;
- //==========================================================================
- //= Selection
- //==========================================================================
+ //==========================================================================
+ //= Selection
+ //==========================================================================
/** Typ of interval bounds */
bound_type boundtype()const { return _boundtype; }
- //==========================================================================
- //= Addition
- //==========================================================================
+ //==========================================================================
+ //= Addition
+ //==========================================================================
/** Extend <tt>*this</tt> to <tt>x2</tt> yielding an interval from the
- minimum of lower bounds to the
- maximum of upper bounds */
+ minimum of lower bounds to the
+ maximum of upper bounds */
interval& extend(const interval& x2);
- /** Interval spanning from lower bound of \c *this interval to the upper bound of \c rhs.
+ /** Interval spanning from lower bound of \c *this interval to the upper bound of \c rhs.
Bordertypes according to the lower bound of \c *this and the upper bound of \c rhs. */
interval span(const interval& rhs)const
{
@@ -198,30 +198,30 @@
}
- //==========================================================================
- //= Subtraction
- //==========================================================================
+ //==========================================================================
+ //= Subtraction
+ //==========================================================================
/** subtract \c x2 from \c *this interval on it's left side. Assign the difference
- to \c right_over. The result \c right_over is the part of \c *this right of \c x2.
+ to \c right_over. The result \c right_over is the part of \c *this right of \c x2.
\code
right_over = x1 - x2; //on the left.
... d) : x1
... c) : x2; x1.left_subtract(right_over, x2);
[c d) : right_over
\endcode
- */
+ */
void left_subtract(interval& right_over, const interval& x2)const;
/** subtract \c x2 from \c *this interval on it's right side. Assign the difference
- to \c left_over. The result \c left_over is the part of \c *this left of \c x2.
+ to \c left_over. The result \c left_over is the part of \c *this left of \c x2.
\code
left_over = x1 - x2; //on the right side.
[a ... : x1
[b ... : x2; x1.right_subtract(left_over, x2);
[a b) : left_over
\endcode
- */
+ */
void right_subtract(interval& left_over, const interval& x2)const;
/** subtract \c x2 from \c *this interval on it's left side.
@@ -231,8 +231,8 @@
... c) : x2;
[c d) : *this
\endcode
- */
- interval& left_subtract(const interval& x2);
+ */
+ interval& left_subtract(const interval& x2);
/** subtract \c x2 from \c *this interval on it's right side.
\code
@@ -241,70 +241,70 @@
[b ... : x2;
[a b) : *this
\endcode
- */
- interval& right_subtract(const interval& x2);
+ */
+ interval& right_subtract(const interval& x2);
- //==========================================================================
- //= Intersection
- //==========================================================================
+ //==========================================================================
+ //= Intersection
+ //==========================================================================
- /** Intersection with the interval <tt>x2</tt>; assign result to <tt>isec</tt> */
+ /** Intersection with the interval <tt>x2</tt>; assign result to <tt>isec</tt> */
// void intersect(interval& isec, const interval& x2)const
- //{
- // isec = *this;
- // isec &= x2;
- //}
-
- interval& operator &= (const interval& sectant)
- {
- set_lwb(lwb_max(sectant));
- set_upb(upb_min(sectant));
- return *this;
- }
-
-
-
- //==========================================================================
- //= Representation
- //==========================================================================
-
- /** Object as string */
+ //{
+ // isec = *this;
+ // isec &= x2;
+ //}
+
+ interval& operator &= (const interval& sectant)
+ {
+ set_lwb(lwb_max(sectant));
+ set_upb(upb_min(sectant));
+ return *this;
+ }
+
+
+
+ //==========================================================================
+ //= Representation
+ //==========================================================================
+
+ /** Object as string */
const std::string as_string()const;
- /** What type is the interval?
+ /** What type is the interval?
\code
interval.is(closed_bounded); //[x, y] a closed interval
interval.is(right_open); //[x, y) a right-open interval (also left-closed interval)
interval.is(left_open); //(x, y] a left-open interval (also right-closed interval)
interval.is(open_bounded); //(x, y) an open interval
\endcode
- */
+ */
bool is(bound_type bounded)const { return _boundtype == bounded; }
- /** What bound type is the left interval border?
+ /** What bound type is the left interval border?
\code
interval.is_left(closed_bounded); //[x, y] or [x, y)
interval.is_left(open_bounded); //(x, y] or (x, y)
\endcode
- */
- bool is_left(bound_type bounded)const
- {
- BOOST_ASSERT(bounded == itl::open_bounded || bounded == itl::closed_bounded);
- return ((_boundtype & right_open)>>1) == (bounded>>1);
- }
+ */
+ bool is_left(bound_type bounded)const
+ {
+ BOOST_ASSERT(bounded == itl::open_bounded || bounded == itl::closed_bounded);
+ return ((_boundtype & right_open)>>1) == (bounded>>1);
+ }
- /** What bound type is the right interval border?
+ /** What bound type is the right interval border?
\code
interval.is_right(closed_bounded); //[x, y] or (x, y]
interval.is_right(open_bounded); //[x, y) or (x, y)
\endcode
- */
- bool is_right(bound_type bounded)const
- {
- BOOST_ASSERT(bounded == itl::open_bounded || bounded == itl::closed_bounded);
- return ((_boundtype & left_open) == (bounded>>1));
- }
+ */
+ bool is_right(bound_type bounded)const
+ {
+ BOOST_ASSERT(bounded == itl::open_bounded || bounded == itl::closed_bounded);
+ return ((_boundtype & left_open) == (bounded>>1));
+ }
/** There is no gap between <tt>*this</tt> and <tt>x2</tt> but they have no element in common */
@@ -313,7 +313,7 @@
/** Maximal element of <tt>*this</tt> is less than the minimal element of <tt>x2</tt> */
bool exclusive_less(const interval& x2)const;
- /** Set \c *this interval to from \c low to \c up with boundtype \c bounds */
+ /** Set \c *this interval to from \c low to \c up with boundtype \c bounds */
interval& set(const DomainT& low, const DomainT& up, bound_type bounds)
{ _lwb=low; _upb=up; _boundtype=bounds; return *this; }
@@ -325,42 +325,42 @@
interval.as(left_open).is(left_open) &&
interval.as(open_bounded).is(open_bounded)
\endcode
- */
+ */
interval& as(bound_type bounded);
- /** An interval that covers the complete range of it's domain_type */
+ /** An interval that covers the complete range of it's domain_type */
static interval whole()
{ return interval<DomainT>::closed(std::numeric_limits<DomainT>::min(),
std::numeric_limits<DomainT>::max()); }
- /** First element of \c *this is less than first element of \c x2 */
+ /** First element of \c *this is less than first element of \c x2 */
bool lower_less(const interval& x2)const;
- /** Last element of \c *this is less than last element of \c x2 */
+ /** Last element of \c *this is less than last element of \c x2 */
bool upper_less(const interval& x2)const;
- /** First element of \c *this is less than or equal to the first element of \c x2 */
+ /** First element of \c *this is less than or equal to the first element of \c x2 */
bool lower_less_equal(const interval& x2)const;
- /** Last element of \c *this is less than or equal to the last element of \c x2 */
+ /** Last element of \c *this is less than or equal to the last element of \c x2 */
bool upper_less_equal(const interval& x2)const;
- /** First element of \c *this is equal to the first element of \c x2 */
+ /** First element of \c *this is equal to the first element of \c x2 */
bool lower_equal(const interval& x2)const;
- /** Last element of \c *this is equal to the last element of \c x2 */
+ /** Last element of \c *this is equal to the last element of \c x2 */
bool upper_equal(const interval& x2)const;
public:
typedef typename boost::call_traits<DomainT>::param_type DomainP;
- /** Less compare of interval elements. */
- inline static bool domain_less(DomainP left, DomainP right)
- {return domain_compare()(left, right) ;}
-
- /** Less or equal compare of interval elements. */
- inline static bool domain_less_equal(DomainP left, DomainP right)
- {return !domain_compare()(right, left );}
-
- /** Equality compare of interval elements. */
- inline static bool domain_equal(DomainP left, DomainP right)
- {return !domain_compare()(left, right) && !domain_compare()(right, left);}
+ /** Less compare of interval elements. */
+ inline static bool domain_less(DomainP left, DomainP right)
+ {return domain_compare()(left, right) ;}
+
+ /** Less or equal compare of interval elements. */
+ inline static bool domain_less_equal(DomainP left, DomainP right)
+ {return !domain_compare()(right, left );}
+
+ /** Equality compare of interval elements. */
+ inline static bool domain_equal(DomainP left, DomainP right)
+ {return !domain_compare()(left, right) && !domain_compare()(right, left);}
private:
typedef std::pair<DomainT, bound_type> BoundT;
@@ -401,35 +401,35 @@
template <class DomainT, ITL_COMPARE Compare>
bound_type interval<DomainT,Compare>::succession_bounds()const
{
- if(_boundtype==itl::right_open) return itl::right_open;
+ if(_boundtype==itl::right_open) return itl::right_open;
if(_boundtype==itl::left_open) return itl::left_open;
if(_boundtype==itl::closed_bounded) return itl::open_bounded;
- return itl::closed_bounded;
+ return itl::closed_bounded;
}
template<class IntervalT>
struct continuous_type
{
- typedef typename IntervalT::domain_type domain_type;
+ typedef typename IntervalT::domain_type domain_type;
typedef typename boost::call_traits<domain_type>::param_type DomainP;
- static bool open_bound_less_equal(DomainP x, DomainP y)
- { return IntervalT::domain_less_equal(x,y); } //{ return x <= y; }
+ static bool open_bound_less_equal(DomainP x, DomainP y)
+ { return IntervalT::domain_less_equal(x,y); } //{ return x <= y; }
static bool open_bound_less (DomainP x, DomainP y)
- { return IntervalT::domain_less(x,y); } //{ return x < y; }
+ { return IntervalT::domain_less(x,y); } //{ return x < y; }
};
template<class IntervalT>
struct discrete_type
{
- typedef typename IntervalT::domain_type domain_type;
+ typedef typename IntervalT::domain_type domain_type;
typedef typename boost::call_traits<domain_type>::param_type DomainP;
static bool open_bound_less_equal(DomainP x, DomainP y)
- { return IntervalT::domain_less_equal(x, succ(y)); } //{ return x <= succ(y); }
+ { return IntervalT::domain_less_equal(x, succ(y)); } //{ return x <= succ(y); }
static bool open_bound_less (DomainP x, DomainP y)
- { return IntervalT::domain_less(succ(x),y); } //{ return succ(x) < y ; }
+ { return IntervalT::domain_less(succ(x),y); } //{ return succ(x) < y ; }
};
template <class DomainT, ITL_COMPARE Compare>
@@ -456,21 +456,21 @@
{
static typename IntervalT::size_type cardinality(const IntervalT& x)
{
- typedef typename IntervalT::size_type SizeT;
- if(x.empty())
- return itl::neutron<SizeT>::value();
+ typedef typename IntervalT::size_type SizeT;
+ if(x.empty())
+ return itl::neutron<SizeT>::value();
else if(x.is(itl::closed_bounded) && IntervalT::domain_equal(x.lower(), x.upper()))
return itl::unon<SizeT>::value();
else
return std::numeric_limits<SizeT>::infinity();
- }
+ }
static typename IntervalT::difference_type
length(const IntervalT& x)
{
- return x.empty() ? itl::neutron<typename IntervalT::difference_type>::value()
- : x.upper() - x.lower();
- }
+ return x.empty() ? itl::neutron<typename IntervalT::difference_type>::value()
+ : x.upper() - x.lower();
+ }
static bool unaligned_lwb_equal(const IntervalT& x1, const IntervalT& x2)
{ return false; }
@@ -485,26 +485,26 @@
template<class IntervalT>
struct discrete_interval
{
- typedef typename IntervalT::domain_type domain_type;
+ typedef typename IntervalT::domain_type domain_type;
static typename IntervalT::size_type
cardinality(const IntervalT& x)
{
- return x.empty()? itl::neutron<typename IntervalT::size_type>::value()
- : succ(x.last()-x.first());
- }
+ return x.empty()? itl::neutron<typename IntervalT::size_type>::value()
+ : succ(x.last()-x.first());
+ }
static typename IntervalT::difference_type length(const IntervalT& x)
{
- return x.empty() ?
+ return x.empty() ?
itl::neutron<typename IntervalT::difference_type>::value() :
succ(x.last() - x.first());
- }
+ }
static bool unaligned_lwb_equal(const IntervalT& x1, const IntervalT& x2)
{
if(x1.is_left(open_bounded) && x2.is_left(closed_bounded))
- return IntervalT::domain_equal(succ(x1.lower()), x2.lower() );
+ return IntervalT::domain_equal(succ(x1.lower()), x2.lower() );
else return IntervalT::domain_equal( x1.lower(), succ(x2.lower()));
}
@@ -520,7 +520,7 @@
if(x1.is_right(closed_bounded) && x2.is_left(closed_bounded))
return IntervalT::domain_equal(succ(x1.upper()), x2.lower());
if(x1.is_right(open_bounded) && x2.is_left(open_bounded) )
- return IntervalT::domain_equal(x1.upper(), succ(x2.lower()));
+ return IntervalT::domain_equal(x1.upper(), succ(x2.lower()));
return false;
}
@@ -766,16 +766,16 @@
template <class DomainT, ITL_COMPARE Compare>
inline interval<DomainT,Compare>& interval<DomainT,Compare>::left_subtract(const interval& x2)
{
- if(!x2.exclusive_less(*this))
- set_lwb( BoundT(x2._upb, x2.succession_bounds()) );
+ if(!x2.exclusive_less(*this))
+ set_lwb( BoundT(x2._upb, x2.succession_bounds()) );
return *this;
}
template <class DomainT, ITL_COMPARE Compare>
inline interval<DomainT,Compare>& interval<DomainT,Compare>::right_subtract(const interval& x2)
{
- if(!exclusive_less(x2))
- set_upb( BoundT(x2._lwb, x2.succession_bounds()) );
+ if(!exclusive_less(x2))
+ set_upb( BoundT(x2._lwb, x2.succession_bounds()) );
return *this;
}
@@ -784,9 +784,9 @@
{
if(lower_less(x2)) {
lsur.set_lwb( BoundT(_lwb,boundtype()) );
- if(exclusive_less(x2))
- lsur.set_upb( BoundT(_upb,boundtype()) );
- else
+ if(exclusive_less(x2))
+ lsur.set_upb( BoundT(_upb,boundtype()) );
+ else
lsur.set_upb( upb_leftOf(x2) );
}
else lsur.clear();
@@ -796,9 +796,9 @@
void interval<DomainT,Compare>::left_subtract(interval<DomainT,Compare>& rsur, const interval<DomainT,Compare>& x2)const
{
if(x2.upper_less(*this)) {
- if(x2.exclusive_less(*this))
+ if(x2.exclusive_less(*this))
rsur.set_lwb( BoundT(_lwb,boundtype()) );
- else
+ else
rsur.set_lwb(lwb_rightOf(x2));
rsur.set_upb( BoundT(_upb,boundtype()) );
}
@@ -864,12 +864,12 @@
{
switch(bounded)
{
- case itl::closed_bounded: set(first(), last(), bounded); break;
+ case itl::closed_bounded: set(first(), last(), bounded); break;
case itl::right_open : set(first(), succ(last()), bounded); break;
case itl::left_open : set(pred(first()), last(), bounded); break;
case itl::open_bounded : set(pred(first()), succ(last()), bounded); break;
}
- return *this;
+ return *this;
}
//==============================================================================
@@ -879,7 +879,7 @@
template <class DomainT, ITL_COMPARE Compare>
inline bool operator == (const interval<DomainT,Compare>& lhs, const interval<DomainT,Compare>& rhs)
{
- return (lhs.empty() && rhs.empty()) || (lhs.lower_equal(rhs) && lhs.upper_equal(rhs));
+ return (lhs.empty() && rhs.empty()) || (lhs.lower_equal(rhs) && lhs.upper_equal(rhs));
}
template <class DomainT, ITL_COMPARE Compare>
@@ -890,8 +890,8 @@
template <class DomainT, ITL_COMPARE Compare>
inline bool operator < (const interval<DomainT,Compare>& lhs, const interval<DomainT,Compare>& rhs)
{
- if(lhs.empty()) return !rhs.empty();
- else return lhs.lower_less(rhs) || (lhs.lower_equal(rhs) && lhs.upper_less(rhs));
+ if(lhs.empty()) return !rhs.empty();
+ else return lhs.lower_less(rhs) || (lhs.lower_equal(rhs) && lhs.upper_less(rhs));
}
template <class DomainT, ITL_COMPARE Compare>
@@ -923,7 +923,7 @@
inline itl::interval<DomainT,Compare> operator & (const itl::interval<DomainT,Compare>& left,
const itl::interval<DomainT,Compare>& right)
{
- return itl::interval<DomainT,Compare>(left) &= right;
+ return itl::interval<DomainT,Compare>(left) &= right;
}
template<class CharType, class CharTraits, class DomainT, ITL_COMPARE Compare>
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -51,20 +51,20 @@
typename CodomainT,
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
#ifdef USE_CONCEPTS
- requires std::LessThanComparable<DomainT>
+ requires std::LessThanComparable<DomainT>
#endif
class interval_base_map
{
public:
- //==========================================================================
- //= Associated types
- //==========================================================================
+ //==========================================================================
+ //= Associated types
+ //==========================================================================
typedef interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>
type;
@@ -72,58 +72,58 @@
/// The designated \e derived or \e sub_type of this base class
typedef SubType sub_type;
- /// Auxilliary type for overloadresolution
- typedef type overloadable_type;
+ /// Auxilliary type for overloadresolution
+ typedef type overloadable_type;
- /// Traits of an itl map
- typedef Traits traits;
+ /// Traits of an itl map
+ typedef Traits traits;
- //--------------------------------------------------------------------------
- //- Associated types: Related types
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Related types
+ //--------------------------------------------------------------------------
/// The atomized type representing the corresponding container of elements
typedef typename itl::map<DomainT,CodomainT,
Traits,Compare,Combine,Section,Alloc> atomized_type;
- //--------------------------------------------------------------------------
- //- Associated types: Data
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Data
+ //--------------------------------------------------------------------------
/// Domain type (type of the keys) of the map
typedef DomainT domain_type;
/// Domain type (type of the keys) of the map
typedef CodomainT codomain_type;
/// Auxiliary type to help the compiler resolve ambiguities when using std::make_pair
typedef mapping_pair<domain_type,codomain_type> domain_mapping_type;
- /// Conceptual is a map a set of elements of type \c element_type
+ /// Conceptual is a map a set of elements of type \c element_type
typedef domain_mapping_type element_type;
/// The interval type of the map
typedef Interval<DomainT,Compare> interval_type;
- /// Auxiliary type for overload resolution
- typedef std::pair<interval_type,CodomainT> interval_mapping_type;
- /// Type of an interval containers segment, that is spanned by an interval
- typedef std::pair<interval_type,CodomainT> segment_type;
-
- //--------------------------------------------------------------------------
- //- Associated types: Size
- //--------------------------------------------------------------------------
+ /// Auxiliary type for overload resolution
+ typedef std::pair<interval_type,CodomainT> interval_mapping_type;
+ /// Type of an interval containers segment, that is spanned by an interval
+ typedef std::pair<interval_type,CodomainT> segment_type;
+
+ //--------------------------------------------------------------------------
+ //- Associated types: Size
+ //--------------------------------------------------------------------------
/// The difference type of an interval which is sometimes different form the domain_type
typedef typename interval_type::difference_type difference_type;
/// The size type of an interval which is mostly std::size_t
typedef typename interval_type::size_type size_type;
- //--------------------------------------------------------------------------
- //- Associated types: Functors
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Functors
+ //--------------------------------------------------------------------------
/// Comparison functor for domain values
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
/// Combine functor for codomain value aggregation
typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
- /// Inverse Combine functor for codomain value aggregation
- typedef typename inverse<codomain_combine>::type inverse_codomain_combine;
+ /// Inverse Combine functor for codomain value aggregation
+ typedef typename inverse<codomain_combine>::type inverse_codomain_combine;
/// Intersection functor for codomain values
typedef ITL_SECTION_CODOMAIN(Section,CodomainT) codomain_intersect;
- /// Inverse Combine functor for codomain value intersection
- typedef typename inverse<codomain_intersect>::type inverse_codomain_intersect;
+ /// Inverse Combine functor for codomain value intersection
+ typedef typename inverse<codomain_intersect>::type inverse_codomain_intersect;
/// Comparison functor for intervals which are keys as well
typedef exclusive_less<interval_type> interval_compare;
@@ -131,9 +131,9 @@
/// Comparison functor for keys
typedef exclusive_less<interval_type> key_compare;
- //--------------------------------------------------------------------------
- //- Associated types: Implementation and stl related
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Implementation and stl related
+ //--------------------------------------------------------------------------
/// The allocator type of the set
typedef Alloc<std::pair<const interval_type, codomain_type> >
allocator_type;
@@ -157,17 +157,17 @@
typedef typename ImplMapT::reverse_iterator reverse_iterator;
/// const_iterator for iteration over intervals
typedef typename ImplMapT::const_reverse_iterator const_reverse_iterator;
-
+
public:
inline static bool has_symmetric_difference()
{ return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }
- enum{ is_itl_container = true };
+ enum{ is_itl_container = true };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/** Default constructor for the empty object */
interval_base_map(){}
@@ -189,9 +189,9 @@
interval_base_map& assign_if(const interval_base_map& src, const Predicate& pred)
{ _map.assign_if(src._map, pred); return *this; }
- //==========================================================================
- //= Emptieness, containment
- //==========================================================================
+ //==========================================================================
+ //= Emptieness, containment
+ //==========================================================================
/** clear the map */
void clear() { _map.clear(); }
@@ -209,15 +209,15 @@
/** Does the map contain the <tt>key_value_pair = (key,value)</tt>? */
bool contains(const element_type& key_value_pair)const
- {
- return that()->contains_(value_type(interval_type(key_value_pair.key),
- key_value_pair.data));
- }
+ {
+ return that()->contains_(value_type(interval_type(key_value_pair.key),
+ key_value_pair.data));
+ }
/** Does the map contain all element value pairs represented by the
- \c interval_value_pair ? */
+ \c interval_value_pair ? */
bool contains(const segment_type& interval_value_pair)const
- { return that()->contains_(interval_value_pair); }
+ { return that()->contains_(interval_value_pair); }
/** Does <tt>*this</tt> container contain <tt>sub</tt>? */
bool contains(const interval_base_map& sub)const
@@ -225,13 +225,13 @@
/** <tt>*this</tt> is subset of <tt>super</tt>? */
bool contained_in(const interval_base_map& super)const
- {
- return Interval_Set::is_contained_in(*this, super);
- }
-
- //==========================================================================
- //= Size
- //==========================================================================
+ {
+ return Interval_Set::is_contained_in(*this, super);
+ }
+
+ //==========================================================================
+ //= Size
+ //==========================================================================
/** Number of elements in the map (cardinality). */
size_type cardinality()const;
@@ -240,19 +240,19 @@
size_type size()const { return cardinality(); }
/** The length of the interval container which is the sum of
- interval lenghts */
+ interval lenghts */
difference_type length()const;
/** Number of intervals which is also the size of the
- iteration over the object */
+ iteration over the object */
size_t interval_count()const { return _map.size(); }
/** Size of the iteration over this container */
size_t iterative_size()const { return _map.size(); }
- //==========================================================================
- //= Range
- //==========================================================================
+ //==========================================================================
+ //= Range
+ //==========================================================================
/** Lower bound of the first interval */
DomainT lower()const
@@ -262,20 +262,20 @@
DomainT upper()const
{ return empty()? interval_type().upper() : (*(_map.rbegin())).KEY_VALUE.upper(); }
- /** Smallest element of the map (wrt. the partial ordering on DomainT).
+ /** Smallest element of the map (wrt. the partial ordering on DomainT).
first() does not exist for continuous datatypes and open interval
- bounds. */
+ bounds. */
DomainT first()const { return (*(_map.begin())).KEY_VALUE.first(); }
/** Largest element of the map (wrt. the partial ordering on DomainT).
last() does not exist for continuous datatypes and open interval
- bounds. */
+ bounds. */
DomainT last()const { return (*(_map.rbegin())).KEY_VALUE.last(); }
- //==========================================================================
- //= Selection
- //==========================================================================
+ //==========================================================================
+ //= Selection
+ //==========================================================================
/** Find the interval value pair, that contains \c key */
const_iterator find(const domain_type& key)const
@@ -284,117 +284,117 @@
return it;
}
- /** Total select function. */
- codomain_type operator()(const domain_type& key)const
- {
+ /** Total select function. */
+ codomain_type operator()(const domain_type& key)const
+ {
const_iterator it = _map.find(interval_type(key));
- return it==end() ? neutron<codomain_type>::value()
- : it->CONT_VALUE;
- }
+ return it==end() ? neutron<codomain_type>::value()
+ : it->CONT_VALUE;
+ }
- //==========================================================================
- //= Addition
- //==========================================================================
+ //==========================================================================
+ //= Addition
+ //==========================================================================
private:
- /** Addition of an interval value pair to the map.
- On overlap an aggregation is performed using functor \c Combiner.
- This function is not public, because the `codomain_combine` shall be
- an invariant for all itl maps.*/
+ /** Addition of an interval value pair to the map.
+ On overlap an aggregation is performed using functor \c Combiner.
+ This function is not public, because the `codomain_combine` shall be
+ an invariant for all itl maps.*/
template<class Combiner>
- SubType& add(const segment_type& interval_value_pair)
- { that()->template add_<Combiner>(interval_value_pair); return *that(); }
+ SubType& add(const segment_type& interval_value_pair)
+ { that()->template add_<Combiner>(interval_value_pair); return *that(); }
public:
- /** Addition of a key value pair to the map */
+ /** Addition of a key value pair to the map */
SubType& add(const element_type& key_value_pair)
{ return add( value_type(interval_type(key_value_pair.key), key_value_pair.data) ); }
- /** Addition of an interval value pair to the map. */
+ /** Addition of an interval value pair to the map. */
SubType& add(const segment_type& interval_value_pair)
- { that()->template add_<codomain_combine>(interval_value_pair); return *that(); }
+ { that()->template add_<codomain_combine>(interval_value_pair); return *that(); }
- //==========================================================================
- //= Subtraction
- //==========================================================================
+ //==========================================================================
+ //= Subtraction
+ //==========================================================================
private:
- /** Subtraction of an interval value pair from the map.
- On overlap an aggregation is performed using functor Combiner.
- This function is not public, because the `codomain_combine` shall be
- an invariant for all itl maps.*/
+ /** Subtraction of an interval value pair from the map.
+ On overlap an aggregation is performed using functor Combiner.
+ This function is not public, because the `codomain_combine` shall be
+ an invariant for all itl maps.*/
template<class Combiner>
void subtract(const segment_type& interval_value_pair)
{ that()->template subtract_<Combiner>(interval_value_pair); }
public:
- /** Subtraction of a key value pair from the map */
+ /** Subtraction of a key value pair from the map */
SubType& subtract(const element_type& key_value_pair)
{
- return subtract( value_type(interval_type(key_value_pair.key),
- key_value_pair.data) );
+ return subtract( value_type(interval_type(key_value_pair.key),
+ key_value_pair.data) );
}
- /** Subtraction of an interval value pair from the map. */
+ /** Subtraction of an interval value pair from the map. */
SubType& subtract(const segment_type& interval_value_pair)
{
- if(Traits::is_total && has_inverse<codomain_type>::value)
- that()->template add_<inverse_codomain_combine>(interval_value_pair);
+ if(Traits::is_total && has_inverse<codomain_type>::value)
+ that()->template add_<inverse_codomain_combine>(interval_value_pair);
else
- that()->template subtract_<inverse_codomain_combine>(interval_value_pair);
+ that()->template subtract_<inverse_codomain_combine>(interval_value_pair);
return *that();
}
- //==========================================================================
- //= Insertion
- //==========================================================================
+ //==========================================================================
+ //= Insertion
+ //==========================================================================
/** Insertion of a \c key_value_pair into the map. */
SubType& insert(const element_type& key_value_pair)
{
- that()->insert(value_type(interval_type(key_value_pair.key),
- key_value_pair.data));
+ that()->insert(value_type(interval_type(key_value_pair.key),
+ key_value_pair.data));
return *that();
}
/** Insertion of an \c interval_value_pair into the map. */
SubType& insert(const segment_type& interval_value_pair)
- { that()->insert_(interval_value_pair); return *that(); }
+ { that()->insert_(interval_value_pair); return *that(); }
/** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
SubType& set(const element_type& key_value_pair)
{
- that()->set(value_type(interval_type(key_value_pair.key),
- key_value_pair.data));
+ that()->set(value_type(interval_type(key_value_pair.key),
+ key_value_pair.data));
return *that();
}
/** With <tt>interval_value_pair = (I,v)</tt> set value \c v
- for all keys in interval \c I in the map. */
+ for all keys in interval \c I in the map. */
SubType& set(const segment_type& interval_value_pair)
- {
- erase(interval_value_pair.KEY_VALUE);
- that()->insert_(interval_value_pair);
- return *that();
- }
+ {
+ erase(interval_value_pair.KEY_VALUE);
+ that()->insert_(interval_value_pair);
+ return *that();
+ }
- //==========================================================================
- //= Erasure
- //==========================================================================
+ //==========================================================================
+ //= Erasure
+ //==========================================================================
/** Erase a \c key_value_pair from the map. */
SubType& erase(const element_type& key_value_pair)
{
- that()->erase_(value_type(interval_type(key_value_pair.key), key_value_pair.data));
+ that()->erase_(value_type(interval_type(key_value_pair.key), key_value_pair.data));
return *that();
}
- /** Erase an \c interval_value_pair from the map. */
+ /** Erase an \c interval_value_pair from the map. */
SubType& erase(const segment_type& interval_value_pair)
- { that()->erase_(interval_value_pair); return *that(); }
+ { that()->erase_(interval_value_pair); return *that(); }
/** Erase a key value pair for \c key. */
@@ -403,7 +403,7 @@
/** Erase all value pairs within the range of the
- interval <tt>inter_val</tt> from the map. */
+ interval <tt>inter_val</tt> from the map. */
SubType& erase(const interval_type& inter_val);
/** Erase all value pairs for a set of intervals. */
@@ -412,7 +412,7 @@
{
typedef interval_base_set<SetSubType,DomainT,Compare,Interval,Alloc> interval_base_set_type;
for(typename interval_base_set_type::const_iterator interval_ = eraser.begin();
- interval_ != eraser.end(); ++interval_)
+ interval_ != eraser.end(); ++interval_)
erase(*interval_);
return *that();
@@ -423,32 +423,32 @@
SubType& erase(const interval_base_map& eraser);
- /** Remove all elements where property <tt>p</tt> holds, keep all others */
+ /** Remove all elements where property <tt>p</tt> holds, keep all others */
template<class Predicate>
interval_base_map& erase_if(const Predicate& pred)
- { _map.erase_if(pred); return *this; }
+ { _map.erase_if(pred); return *this; }
- //==========================================================================
- //= Intersection
- //==========================================================================
+ //==========================================================================
+ //= Intersection
+ //==========================================================================
- /** The intersection of \c key in \c *this map is added to \c section.
- This can also be used to find \c key in \c *this map */
+ /** The intersection of \c key in \c *this map is added to \c section.
+ This can also be used to find \c key in \c *this map */
void add_intersection(interval_base_map& section, const domain_type& key)const
{ add_intersection(section, interval_type(key)); }
- /** The intersection of \c key_value_pair and \c *this map is added to \c section. */
+ /** The intersection of \c key_value_pair and \c *this map is added to \c section. */
void add_intersection(interval_base_map& section, const element_type& key_value_pair)const
{ add_intersection(section, value_type(interval_type(key_value_pair.key), key_value_pair.data)); }
- /** The intersection of \c interval_value_pair and \c *this map is added to \c section. */
+ /** The intersection of \c interval_value_pair and \c *this map is added to \c section. */
void add_intersection(interval_base_map& section, const segment_type& interval_value_pair)const;
- /** The intersection of \c inter_val with \c *this map is added to \c section. */
+ /** The intersection of \c inter_val with \c *this map is added to \c section. */
void add_intersection(interval_base_map& section, const interval_type& inter_val)const;
- /** The intersection of set \c sectant with \c *this map is added to \c section. */
+ /** The intersection of set \c sectant with \c *this map is added to \c section. */
template
<
template
@@ -464,10 +464,10 @@
typedef IntervalSet<DomainT,Compare,Interval,Alloc> sectant_type;
if(sectant.empty()) return;
- typename sectant_type::const_iterator common_lwb;
- typename sectant_type::const_iterator common_upb;
- if(!Set::common_range(common_lwb, common_upb, sectant, *this))
- return;
+ typename sectant_type::const_iterator common_lwb;
+ typename sectant_type::const_iterator common_upb;
+ if(!Set::common_range(common_lwb, common_upb, sectant, *this))
+ return;
typename sectant_type::const_iterator it = common_lwb;
while(it != common_upb)
@@ -475,7 +475,7 @@
}
- /** The intersection of map \c sectant with \c *this map is added to \c section. */
+ /** The intersection of map \c sectant with \c *this map is added to \c section. */
template
<
template
@@ -493,19 +493,19 @@
)const;
- //==========================================================================
- //= Symmetric difference
- //==========================================================================
+ //==========================================================================
+ //= Symmetric difference
+ //==========================================================================
- /** If \c *this map contains \c key_value_pair it is erased, otherwise it is added. */
+ /** If \c *this map contains \c key_value_pair it is erased, otherwise it is added. */
SubType& flip(const element_type& key_value_pair)
- { return flip(value_type(interval_type(key_value_pair.key), key_value_pair.data)); }
+ { return flip(value_type(interval_type(key_value_pair.key), key_value_pair.data)); }
- /** If \c *this map contains \c interval_value_pair it is erased, otherwise it is added. */
+ /** If \c *this map contains \c interval_value_pair it is erased, otherwise it is added. */
SubType& flip(const segment_type& interval_value_pair);
- /** The intersection of \c *this and \c operand is erased from \c *this.
- The complemenary value pairs are added to \c *this. */
+ /** The intersection of \c *this and \c operand is erased from \c *this.
+ The complemenary value pairs are added to \c *this. */
template
<
template
@@ -519,9 +519,9 @@
SubType& flip(const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand);
- //==========================================================================
- //= Iterator related
- //==========================================================================
+ //==========================================================================
+ //= Iterator related
+ //==========================================================================
iterator lower_bound(const key_type& interval)
{ return _map.lower_bound(interval); }
@@ -544,17 +544,17 @@
const_reverse_iterator rbegin()const { return _map.rbegin(); }
const_reverse_iterator rend()const { return _map.rend(); }
- //==========================================================================
- //= Representation
- //==========================================================================
-
- /** Object as string */
+ //==========================================================================
+ //= Representation
+ //==========================================================================
+
+ /** Object as string */
std::string as_string()const;
- //==========================================================================
- //= Morphisms
- //==========================================================================
+ //==========================================================================
+ //= Morphisms
+ //==========================================================================
/** Join bounding intervals */
interval_base_map& join();
@@ -569,19 +569,19 @@
}
/** Set all intervals in the map to be of type <tt>bounded</tt>.
- Requires Integral<domain_type>.
+ Requires Integral<domain_type>.
Interval bounds of different types are created by opeations on
interval maps. This function allows to reset them uniformly without,
of course, changing their value. This is only possible for discrete
domain datatypes.
*/
- void uniform_bounds(itl::bound_type bounded);
+ void uniform_bounds(itl::bound_type bounded);
- //==========================================================================
- //= Domain, sum
- //==========================================================================
+ //==========================================================================
+ //= Domain, sum
+ //==========================================================================
/** Gives the domain of the map as interval set */
template
@@ -602,12 +602,12 @@
/* Sum of associated elements of the map */
codomain_type sum()const
- { codomain_type total; sum(total); return total; }
+ { codomain_type total; sum(total); return total; }
- //==========================================================================
- //= Algorithm unifiers
- //==========================================================================
+ //==========================================================================
+ //= Algorithm unifiers
+ //==========================================================================
template<typename IteratorT>
static const key_type& key_value(IteratorT& value_){ return (*value_).first; }
@@ -629,7 +629,7 @@
const sub_type* that()const { return static_cast<const sub_type*>(this); }
public:
- sub_type& self() { return *that(); }
+ sub_type& self() { return *that(); }
protected:
ImplMapT _map;
@@ -705,23 +705,23 @@
typedef IntervalMap<DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc> sectant_type;
- if(Traits::is_total)
- {
- intersection = *this;
- intersection += sectant;
- }
- else
- {
- if(sectant.empty())
- return;
- typename sectant_type::const_iterator common_lwb;
- typename sectant_type::const_iterator common_upb;
- if(!Set::common_range(common_lwb, common_upb, sectant, *this))
- return;
- typename sectant_type::const_iterator it = common_lwb;
- while(it != common_upb)
- add_intersection(intersection, *it++);
- }
+ if(Traits::is_total)
+ {
+ intersection = *this;
+ intersection += sectant;
+ }
+ else
+ {
+ if(sectant.empty())
+ return;
+ typename sectant_type::const_iterator common_lwb;
+ typename sectant_type::const_iterator common_upb;
+ if(!Set::common_range(common_lwb, common_upb, sectant, *this))
+ return;
+ typename sectant_type::const_iterator it = common_lwb;
+ while(it != common_upb)
+ add_intersection(intersection, *it++);
+ }
}
template
@@ -734,33 +734,33 @@
const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::segment_type& sectant)const
{
- if(Traits::is_total)
- {
- section = *this;
- section.add(sectant);
- }
- else
- {
- interval_type sectant_interval = sectant.KEY_VALUE;
- if(sectant_interval.empty()) return;
-
- typename ImplMapT::const_iterator fst_it = _map.lower_bound(sectant_interval);
- typename ImplMapT::const_iterator end_it = _map.upper_bound(sectant_interval);
-
- for(typename ImplMapT::const_iterator it=fst_it; it != end_it; it++)
- {
- interval_type common_interval = ((*it).KEY_VALUE) & sectant_interval;
-
- if(!common_interval.empty())
- {
- section.that()->add( value_type(common_interval, (*it).CONT_VALUE) );
- if(is_set<CodomainT>::value)
- section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.CONT_VALUE));
- else
- section.that()->template add<codomain_combine>(value_type(common_interval, sectant.CONT_VALUE));
- }
- }
- }
+ if(Traits::is_total)
+ {
+ section = *this;
+ section.add(sectant);
+ }
+ else
+ {
+ interval_type sectant_interval = sectant.KEY_VALUE;
+ if(sectant_interval.empty()) return;
+
+ typename ImplMapT::const_iterator fst_it = _map.lower_bound(sectant_interval);
+ typename ImplMapT::const_iterator end_it = _map.upper_bound(sectant_interval);
+
+ for(typename ImplMapT::const_iterator it=fst_it; it != end_it; it++)
+ {
+ interval_type common_interval = ((*it).KEY_VALUE) & sectant_interval;
+
+ if(!common_interval.empty())
+ {
+ section.that()->add( value_type(common_interval, (*it).CONT_VALUE) );
+ if(is_set<CodomainT>::value)
+ section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.CONT_VALUE));
+ else
+ section.that()->template add<codomain_combine>(value_type(common_interval, sectant.CONT_VALUE));
+ }
+ }
+ }
}
@@ -797,79 +797,79 @@
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
- ::flip(const segment_type& interval_value_pair)
+ ::flip(const segment_type& interval_value_pair)
{
// That which is common shall be subtracted
- // That which is not shall be added
- // So x has to be 'complementary added' or flipped
+ // That which is not shall be added
+ // So x has to be 'complementary added' or flipped
- if(Traits::is_total && Traits::absorbs_neutrons)
- {
- clear();
- return *that();
- }
- if(Traits::is_total && !Traits::absorbs_neutrons)
- {
- (*that()) += interval_value_pair;
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ if(Traits::is_total && Traits::absorbs_neutrons)
+ {
+ clear();
+ return *that();
+ }
+ if(Traits::is_total && !Traits::absorbs_neutrons)
+ {
+ (*that()) += interval_value_pair;
+ FORALL(typename ImplMapT, it_, _map)
+ it_->CONT_VALUE = neutron<codomain_type>::value();
- if(!is_interval_splitter<SubType>::value)
- join();
+ if(!is_interval_splitter<SubType>::value)
+ join();
- return *that();
- }
+ return *that();
+ }
- interval_type span = interval_value_pair.KEY_VALUE;
+ interval_type span = interval_value_pair.KEY_VALUE;
typename ImplMapT::const_iterator fst_it = _map.lower_bound(span);
typename ImplMapT::const_iterator end_it = _map.upper_bound(span);
- interval_type covered, left_over, common_interval;
- const codomain_type& x_value = interval_value_pair.CONT_VALUE;
- typename ImplMapT::const_iterator it = fst_it;
+ interval_type covered, left_over, common_interval;
+ const codomain_type& x_value = interval_value_pair.CONT_VALUE;
+ typename ImplMapT::const_iterator it = fst_it;
while(it != end_it)
{
- const codomain_type& co_value = it->CONT_VALUE;
- covered = (*it++).KEY_VALUE;
- //[a ... : span
- // [b ... : covered
- //[a b) : left_over
- span.right_subtract(left_over, covered);
-
- //That which is common ...
- common_interval = span & covered;
- if(!common_interval.empty())
- {
- // ... shall be subtracted
- if(is_set<codomain_type>::value)
- {
- codomain_type common_value = x_value;
- inverse_codomain_intersect()(common_value, co_value);
- erase(common_interval);
- add(value_type(common_interval, common_value));
- }
- else
- subtract(value_type(common_interval, co_value));
- }
-
- add(value_type(left_over, x_value)); //That which is not shall be added
- // Because this is a collision free addition I don't have to distinguish codomain_types.
-
- //... d) : span
- //... c) : (*it); span.left_subtract(*it);
- // [c d) : span'
- span.left_subtract(covered);
- }
-
- //If span is not empty here, it is not in the set so it shall be added
- add(value_type(span, x_value));
-
- if(Traits::is_total && !Traits::absorbs_neutrons)
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ const codomain_type& co_value = it->CONT_VALUE;
+ covered = (*it++).KEY_VALUE;
+ //[a ... : span
+ // [b ... : covered
+ //[a b) : left_over
+ span.right_subtract(left_over, covered);
+
+ //That which is common ...
+ common_interval = span & covered;
+ if(!common_interval.empty())
+ {
+ // ... shall be subtracted
+ if(is_set<codomain_type>::value)
+ {
+ codomain_type common_value = x_value;
+ inverse_codomain_intersect()(common_value, co_value);
+ erase(common_interval);
+ add(value_type(common_interval, common_value));
+ }
+ else
+ subtract(value_type(common_interval, co_value));
+ }
+
+ add(value_type(left_over, x_value)); //That which is not shall be added
+ // Because this is a collision free addition I don't have to distinguish codomain_types.
- return *that();
+ //... d) : span
+ //... c) : (*it); span.left_subtract(*it);
+ // [c d) : span'
+ span.left_subtract(covered);
+ }
+
+ //If span is not empty here, it is not in the set so it shall be added
+ add(value_type(span, x_value));
+
+ if(Traits::is_total && !Traits::absorbs_neutrons)
+ FORALL(typename ImplMapT, it_, _map)
+ it_->CONT_VALUE = neutron<codomain_type>::value();
+
+ return *that();
}
@@ -896,46 +896,46 @@
{
typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
- if(Traits::is_total && Traits::absorbs_neutrons)
- {
- clear();
- return *that();
- }
- if(Traits::is_total && !Traits::absorbs_neutrons)
- {
- (*that()) += operand;
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ if(Traits::is_total && Traits::absorbs_neutrons)
+ {
+ clear();
+ return *that();
+ }
+ if(Traits::is_total && !Traits::absorbs_neutrons)
+ {
+ (*that()) += operand;
+ FORALL(typename ImplMapT, it_, _map)
+ it_->CONT_VALUE = neutron<codomain_type>::value();
- if(!is_interval_splitter<SubType>::value)
- join();
+ if(!is_interval_splitter<SubType>::value)
+ join();
- return *that();
- }
+ return *that();
+ }
typename operand_type::const_iterator common_lwb;
typename operand_type::const_iterator common_upb;
if(!Set::common_range(common_lwb, common_upb, operand, *this))
- return *that() += operand;
+ return *that() += operand;
typename operand_type::const_iterator it = operand.begin();
- // All elements of operand left of the common range are added
+ // All elements of operand left of the common range are added
while(it != common_lwb)
add(*it++);
- // All elements of operand in the common range are symmertrically subtracted
+ // All elements of operand in the common range are symmertrically subtracted
while(it != common_upb)
flip(*it++);
- // All elements of operand right of the common range are added
+ // All elements of operand right of the common range are added
while(it != operand.end())
add(*it++);
- if(Traits::is_total && !Traits::absorbs_neutrons)
- FORALL(typename ImplMapT, it_, _map)
- it_->CONT_VALUE = neutron<codomain_type>::value();
+ if(Traits::is_total && !Traits::absorbs_neutrons)
+ FORALL(typename ImplMapT, it_, _map)
+ it_->CONT_VALUE = neutron<codomain_type>::value();
- return *that();
+ return *that();
}
@@ -1017,7 +1017,7 @@
void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::sum(codomain_type& total)const
{
- total = codomain_combine::neutron();
+ total = codomain_combine::neutron();
const_FOR_IMPLMAP(it)
total += (*it).CONT_VALUE;
}
@@ -1083,7 +1083,7 @@
::erase(const interval_base_map& erasure)
{
const_FORALL(typename interval_base_map, value_pair_, erasure)
- that()->erase_(*value_pair_);
+ that()->erase_(*value_pair_);
return *that();
}
@@ -1130,7 +1130,7 @@
inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
{
- return Map::lexicographical_protonic_equal(lhs, rhs);
+ return Map::lexicographical_protonic_equal(lhs, rhs);
}
@@ -1262,8 +1262,8 @@
>
struct is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template
@@ -1273,8 +1273,8 @@
>
struct is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template
@@ -1284,8 +1284,8 @@
>
struct has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ typedef has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = has_inverse<CodomainT>::value;
};
template
@@ -1295,8 +1295,8 @@
>
struct is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -37,26 +37,26 @@
class interval_base_set
{
public:
- //==========================================================================
- //= Associated types
- //==========================================================================
+ //==========================================================================
+ //= Associated types
+ //==========================================================================
typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> type;
/// The designated \e derived or \e sub_type of this base class
typedef SubType sub_type;
- /// Auxilliary type for overloadresolution
- typedef type overloadable_type;
+ /// Auxilliary type for overloadresolution
+ typedef type overloadable_type;
- //--------------------------------------------------------------------------
- //- Associated types: Related types
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Related types
+ //--------------------------------------------------------------------------
/// The atomized type representing the corresponding container of elements
typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
- //--------------------------------------------------------------------------
- //- Associated types: Data
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Data
+ //--------------------------------------------------------------------------
/// The domain type of the set
typedef DomainT domain_type;
/// The codomaintype is the same as domain_type
@@ -70,9 +70,9 @@
/// The segment type of the set
typedef interval_type segment_type;
- //--------------------------------------------------------------------------
- //- Associated types: Size
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Size
+ //--------------------------------------------------------------------------
/// The difference type of an interval which is sometimes different form the data_type
typedef typename interval_type::difference_type difference_type;
@@ -80,9 +80,9 @@
typedef typename interval_type::size_type size_type;
- //--------------------------------------------------------------------------
- //- Associated types: Order
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Order
+ //--------------------------------------------------------------------------
/// Comparison functor for domain values
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
/// Comparison functor for intervals
@@ -91,9 +91,9 @@
/// Comparison functor for keys
typedef exclusive_less<interval_type> key_compare;
- //--------------------------------------------------------------------------
- //- Associated types: Implementation and stl related
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ //- Associated types: Implementation and stl related
+ //--------------------------------------------------------------------------
/// The allocator type of the set
typedef Alloc<interval_type> allocator_type;
@@ -121,9 +121,9 @@
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/** Default constructor for the empty object */
interval_base_set(){}
@@ -141,9 +141,9 @@
/** swap the content of containers */
void swap(interval_base_set& x) { _set.swap(x._set); }
- //==========================================================================
- //= Emptieness, containment
- //==========================================================================
+ //==========================================================================
+ //= Emptieness, containment
+ //==========================================================================
/** sets the container empty */
void clear() { _set.clear(); }
@@ -152,7 +152,7 @@
/** Does the container contain the element \c key ? */
bool contains(const element_type& key)const
- { return that()->contains_(interval_type(key)); }
+ { return that()->contains_(interval_type(key)); }
/** Does the container contain the interval \c inter_val ? */
bool contains(const segment_type& inter_val)const
@@ -163,30 +163,30 @@
{ return sub.contained_in(*this); }
/** Does <tt>*this</tt> container contain <tt>sub</tt>? */
- template
+ template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
bool contains(const IntervalSet<DomainT,Compare,Interval,Alloc>& sub)const
{ return sub.contained_in(*that()); }
/** Is <tt>*this</tt> container contained in <tt>super</tt>? */
- template
+ template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
bool contained_in(const IntervalSet<DomainT,Compare,Interval,Alloc>& super)const
- {
- return Interval_Set::is_contained_in(*this, super);
- }
-
- //==========================================================================
- //= Size
- //==========================================================================
+ {
+ return Interval_Set::is_contained_in(*this, super);
+ }
+
+ //==========================================================================
+ //= Size
+ //==========================================================================
/** Number of elements in the set (cardinality).
Infinite for continuous domain datatyps */
@@ -204,9 +204,9 @@
/** Size of the iteration over this container */
std::size_t iterative_size()const { return _set.size(); }
- //==========================================================================
- //= Range
- //==========================================================================
+ //==========================================================================
+ //= Range
+ //==========================================================================
/** lower bound of all intervals in the object */
DomainT lower()const
@@ -217,52 +217,52 @@
/** Smallest element of the set (wrt. the partial ordering on DomainT).
first() does not exist for continuous datatypes and open interval
- bounds. */
+ bounds. */
DomainT first()const { return (*(_set.begin())).first(); }
/** Largest element of the set (wrt. the partial ordering on DomainT).
last() does not exist for continuous datatypes and open interval
- bounds. */
+ bounds. */
DomainT last()const { return (*(_set.rbegin())).last(); }
- //==========================================================================
- //= Selection
- //==========================================================================
+ //==========================================================================
+ //= Selection
+ //==========================================================================
- /** Find the interval value pair, that contains element \c key */
+ /** Find the interval value pair, that contains element \c key */
const_iterator find(const element_type& key)const
{
typename ImplSetT::const_iterator it = this->_set.find(interval_type(key));
return it;
}
- //==========================================================================
- //= Addition
- //==========================================================================
+ //==========================================================================
+ //= Addition
+ //==========================================================================
/** Add a single element \c key to the set */
SubType& add(const element_type& key)
- { that()->add_(interval_type(key)); return *that(); }
+ { that()->add_(interval_type(key)); return *that(); }
/** Add an interval of elements \c inter_val to the set */
SubType& add(const segment_type& inter_val)
{ that()->add_(inter_val); return *that(); }
- //==========================================================================
- //= Subtraction
- //==========================================================================
+ //==========================================================================
+ //= Subtraction
+ //==========================================================================
/** Subtract a single element \c key from the set */
SubType& subtract(const element_type& key)
- { that()->subtract_(interval_type(key)); return *that(); }
+ { that()->subtract_(interval_type(key)); return *that(); }
/** Subtract an interval of elements \c inter_val from the set */
SubType& subtract(const segment_type& inter_val)
{ that()->subtract_(inter_val); return *that(); }
- //==========================================================================
- //= Insertion, erasure
- //==========================================================================
+ //==========================================================================
+ //= Insertion, erasure
+ //==========================================================================
/** Insert an element \c key into the set */
SubType& insert(const element_type& key)
@@ -280,24 +280,24 @@
SubType& erase(const segment_type& inter_val)
{ return subtract(inter_val); }
- //==========================================================================
- //= Intersection
- //==========================================================================
+ //==========================================================================
+ //= Intersection
+ //==========================================================================
- /** The intersection of \c key in \c *this set is added to \c section.
- The function can be used as a find function. */
+ /** The intersection of \c key in \c *this set is added to \c section.
+ The function can be used as a find function. */
void add_intersection(interval_base_set& section, const element_type& key)const
- { add_intersection(section, interval_type(key)); }
+ { add_intersection(section, interval_type(key)); }
- /** The intersection of \c inter_val in \c *this set is added to \c section. */
+ /** The intersection of \c inter_val in \c *this set is added to \c section. */
void add_intersection(interval_base_set& section, const segment_type& inter_val)const;
- /** The intersection of set \c sectant with \c *this set is added to \c section. */
- template
+ /** The intersection of set \c sectant with \c *this set is added to \c section. */
+ template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
void add_intersection
@@ -307,30 +307,30 @@
)const;
- //==========================================================================
- //= Symmetric difference
- //==========================================================================
+ //==========================================================================
+ //= Symmetric difference
+ //==========================================================================
- /** If \c *this set contains \c key it is erased, otherwise it is added. */
+ /** If \c *this set contains \c key it is erased, otherwise it is added. */
SubType& flip(const element_type& key)
- { return flip(interval_type(key)); }
+ { return flip(interval_type(key)); }
- /** If \c *this set contains \c inter_val it is erased, otherwise it is added. */
+ /** If \c *this set contains \c inter_val it is erased, otherwise it is added. */
SubType& flip(const segment_type& inter_val);
- /** The intersection of \c *this and \c operand is erased from \c *this.
- The complemenary elements are added to \c *this. */
- template
+ /** The intersection of \c *this and \c operand is erased from \c *this.
+ The complemenary elements are added to \c *this. */
+ template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
SubType& flip(const IntervalSet<DomainT,Compare,Interval,Alloc>& operand);
- //==========================================================================
- //= Iterator related
- //==========================================================================
+ //==========================================================================
+ //= Iterator related
+ //==========================================================================
iterator begin() { return _set.begin(); }
iterator end() { return _set.end(); }
@@ -354,34 +354,34 @@
{ return _set.upper_bound(interval); }
- //==========================================================================
- //= Morphisms
- //==========================================================================
-
+ //==========================================================================
+ //= Morphisms
+ //==========================================================================
+
/** Join bordering intervals */
interval_base_set& join();
- /** Set interval bounds to the type <tt>bt</tt> for intervals in the set.
+ /** Set interval bounds to the type <tt>bt</tt> for intervals in the set.
Interval bounds of different types are created by opeations on
interval sets. This function allows to reset them uniformly without,
of course, changing their value. This is only possible for discrete
domain datatypes.
*/
- void uniform_bounds(itl::bound_type bounded);
+ void uniform_bounds(itl::bound_type bounded);
- //==========================================================================
- //= Representation
- //==========================================================================
-
+ //==========================================================================
+ //= Representation
+ //==========================================================================
+
/** Interval container's string representation */
const std::string as_string()const
{ std::string res(""); const_FOR_IMPL(it) res += (*it).as_string(); return res; }
- //==========================================================================
- //= Algorithm unifiers
- //==========================================================================
+ //==========================================================================
+ //= Algorithm unifiers
+ //==========================================================================
template<typename IteratorT>
static const key_type& key_value(IteratorT& value_){ return (*value_); }
@@ -402,7 +402,7 @@
const sub_type* that()const { return static_cast<const sub_type*>(this); }
public:
- sub_type& self() { return *that(); }
+ sub_type& self() { return *that(); }
protected:
ImplSetT _set;
@@ -463,7 +463,7 @@
template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
bool interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
@@ -510,7 +510,7 @@
template
<
template<class DomT, ITL_COMPARE Comp,
- template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
class IntervalSet
>
void interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
@@ -523,7 +523,7 @@
typedef IntervalSet<DomainT,Compare,Interval,Alloc> operand_type;
if(operand.empty())
- return;
+ return;
typename operand_type::const_iterator common_lwb;
typename operand_type::const_iterator common_upb;
@@ -543,76 +543,76 @@
template<class SubType,
class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
- ::flip(const segment_type& inter_val)
+ ::flip(const segment_type& inter_val)
{
// That which is common shall be subtracted
- // That which is not shall be added
- // So x has to be 'complementary added' or flipped
- interval_type span = inter_val;
+ // That which is not shall be added
+ // So x has to be 'complementary added' or flipped
+ interval_type span = inter_val;
typename ImplSetT::const_iterator fst_ = _set.lower_bound(span);
typename ImplSetT::const_iterator end_ = _set.upper_bound(span);
- interval_type covered, left_over;
- typename ImplSetT::const_iterator it_ = fst_;
+ interval_type covered, left_over;
+ typename ImplSetT::const_iterator it_ = fst_;
while(it_ != end_)
{
- covered = *it_++;
- //[a ... : span
- // [b ... : covered
- //[a b) : left_over
- span.right_subtract(left_over, covered);
- subtract(span & covered); //That which is common shall be subtracted
- add(left_over); //That which is not shall be added
-
- //... d) : span
- //... c) : (*it); span.left_subtract(*it);
- // [c d) : span'
- span.left_subtract(covered);
+ covered = *it_++;
+ //[a ... : span
+ // [b ... : covered
+ //[a b) : left_over
+ span.right_subtract(left_over, covered);
+ subtract(span & covered); //That which is common shall be subtracted
+ add(left_over); //That which is not shall be added
+
+ //... d) : span
+ //... c) : (*it); span.left_subtract(*it);
+ // [c d) : span'
+ span.left_subtract(covered);
}
- //If span is not empty here, it is not in the set so it shall be added
- add(span);
- return *that();
+ //If span is not empty here, it is not in the set so it shall be added
+ add(span);
+ return *that();
}
template
<
- class SubType,
+ class SubType,
class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
template
<
- template<class DomT, ITL_COMPARE Comp, template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
- class IntervalSet
- >
+ template<class DomT, ITL_COMPARE Comp, template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc>
+ class IntervalSet
+ >
SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::flip(const IntervalSet<DomainT,Compare,Interval,Alloc>& operand)
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> operand_type;
if(operand.empty())
- return *that();
+ return *that();
typename operand_type::const_iterator common_lwb;
typename operand_type::const_iterator common_upb;
if(!Set::common_range(common_lwb, common_upb, operand, *this))
- return *that() += operand;
+ return *that() += operand;
typename operand_type::const_iterator it = operand.begin();
- // All elements of operand left of the common range are added
+ // All elements of operand left of the common range are added
while(it != common_lwb)
add(*it++);
- // All elements of operand in the common range are symmertrically subtracted
+ // All elements of operand in the common range are symmertrically subtracted
while(it != common_upb)
flip(*it++);
- // All elements of operand right of the common range are added
+ // All elements of operand right of the common range are added
while(it != operand.end())
add(*it++);
- return *that();
+ return *that();
}
@@ -700,8 +700,8 @@
{
return std::lexicographical_compare(
lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<Interval<DomainT,Compare> >()//NOTE DESIGN TTP: Why Compare is needs to be ttp
- );
+ Compare<Interval<DomainT,Compare> >()//NOTE DESIGN TTP: Why Compare is needs to be ttp
+ );
}
template<class SubType,
@@ -744,16 +744,16 @@
class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
template<class SubType,
class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -30,7 +30,7 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
@@ -43,7 +43,7 @@
typedef Traits traits;
typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> split_type;
- typedef type overloadable_type;
+ typedef type overloadable_type;
typedef type joint_type;
typedef interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
@@ -54,20 +54,20 @@
typedef typename base_type::element_type element_type;
typedef typename base_type::segment_type segment_type;
typedef typename base_type::domain_mapping_type domain_mapping_type;
- typedef typename base_type::interval_mapping_type interval_mapping_type;
+ typedef typename base_type::interval_mapping_type interval_mapping_type;
typedef typename base_type::ImplMapT ImplMapT;
- typedef typename base_type::codomain_combine codomain_combine;
+ typedef typename base_type::codomain_combine codomain_combine;
typedef interval_set<DomainT,Compare,Interval,Alloc> interval_set_type;
typedef interval_set_type set_type;
- enum { fineness = 1 };
+ enum { fineness = 1 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/// Default constructor for the empty object
interval_map(): base_type() {}
/// Copy constructor
@@ -108,12 +108,12 @@
}
private:
- // The following _suffixed function templates funx_ are implementations
- // correspoding unsuffixed function templates funx of the base class.
- // For funx_ want to be used in the base class via derived SubType pointer:
- // that()->funx_. So they must be either public or made accessible by a
- // friend declaration:
- friend class
+ // The following _suffixed function templates funx_ are implementations
+ // correspoding unsuffixed function templates funx of the base class.
+ // For funx_ want to be used in the base class via derived SubType pointer:
+ // that()->funx_. So they must be either public or made accessible by a
+ // friend declaration:
+ friend class
interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>;
@@ -132,7 +132,7 @@
bool insertable(const value_type& value)const
{
return !value.KEY_VALUE.empty()
- && !(Traits::absorbs_neutrons && value.CONT_VALUE == codomain_combine::neutron());
+ && !(Traits::absorbs_neutrons && value.CONT_VALUE == codomain_combine::neutron());
}
bool join_left(iterator& it);
@@ -152,15 +152,15 @@
template<class Combiner>
void add_rest(const interval_type& x_itv, const CodomainT& x_val,
- iterator& it, iterator& end_it);
+ iterator& it, iterator& end_it);
template<class Combiner>
void add_rear(const interval_type& x_itv, const CodomainT& x_val,
- iterator& it);
+ iterator& it);
template<class Combiner>
void subtract_rest(const interval_type& x_itv, const CodomainT& x_val,
- iterator& it, iterator& end_it);
+ iterator& it, iterator& end_it);
void insert_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it);
void insert_rear(const interval_type& x_itv, const CodomainT& x_val, iterator& it);
@@ -324,9 +324,9 @@
{
CodomainT added_val = Combiner::neutron();
Combiner()(added_val, value.CONT_VALUE);
- if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
- return this->_map.end();
- else
+ if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
+ return this->_map.end();
+ else
insertion = this->_map.insert(value_type(value.KEY_VALUE, added_val));
}
else
@@ -355,9 +355,9 @@
{
CodomainT added_val = Combiner::neutron();
Combiner()(added_val, value.CONT_VALUE);
- if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
- return this->_map.end();
- else
+ if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
+ return this->_map.end();
+ else
insertion = this->_map.insert(value_type(value.KEY_VALUE, added_val));
}
else
@@ -390,10 +390,10 @@
{
CodomainT added_val = Combiner::neutron();
Combiner()(added_val, x_val);
- if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
- return;
- else
- insertion = this->_map.insert(value_type(x_itv, added_val));
+ if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
+ return;
+ else
+ insertion = this->_map.insert(value_type(x_itv, added_val));
}
else
insertion = this->_map.insert(x);
@@ -905,44 +905,44 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ typedef has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = has_inverse<CodomainT>::value;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::absorbs_neutrons;
+ typedef absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = Traits::absorbs_neutrons;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::is_total;
+ typedef is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = Traits::is_total;
};
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/interval_maps.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_maps.hpp (original)
+++ sandbox/itl/boost/itl/interval_maps.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -196,7 +196,7 @@
Traits,Compare,Combine,Section,Interval,Alloc>& right
)
{
- return is_disjoint(right, left);
+ return is_disjoint(right, left);
}
@@ -341,7 +341,7 @@
const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& right
)
{
- return Map::lexicographical_protonic_equal(left, right);
+ return Map::lexicographical_protonic_equal(left, right);
}
//-----------------------------------------------------------------------------
@@ -349,7 +349,7 @@
//-----------------------------------------------------------------------------
template
<
- class ObjectT,
+ class ObjectT,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
@@ -378,7 +378,7 @@
//-----------------------------------------------------------------------------
template
<
- class ObjectT,
+ class ObjectT,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
@@ -407,7 +407,7 @@
//-----------------------------------------------------------------------------
template
<
- class ObjectT,
+ class ObjectT,
class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template
@@ -432,7 +432,7 @@
template
<
class ObjectT,
- class DomainT, class CodomainT, class Traits,
+ class DomainT, class CodomainT, class Traits,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -35,7 +35,7 @@
DomainT,Compare,Interval,Alloc> base_type;
typedef interval_set<DomainT,Compare,Interval,Alloc> type;
- typedef type overloadable_type;
+ typedef type overloadable_type;
typedef type joint_type;
@@ -83,12 +83,12 @@
/// const_iterator for iteration over intervals
typedef typename ImplSetT::const_iterator const_iterator;
- enum { fineness = 1 };
+ enum { fineness = 1 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/// Default constructor for the empty object
interval_set(): base_type() {}
/// Copy constructor
@@ -126,8 +126,8 @@
}
private:
- friend class
- interval_base_set<interval_set<DomainT,Compare,Interval,Alloc>,
+ friend class
+ interval_base_set<interval_set<DomainT,Compare,Interval,Alloc>,
DomainT,Compare,Interval,Alloc>;
/// Does the set contain the interval <tt>x</tt>?
@@ -296,7 +296,7 @@
inline bool is_element_equal(const interval_set<DomainT,Compare,Interval,Alloc>& lhs,
const interval_set<DomainT,Compare,Interval,Alloc>& rhs)
{
- // Since both are joining interval sets we can use the simpler Set::lexicographical_equal
+ // Since both are joining interval sets we can use the simpler Set::lexicographical_equal
return &lhs == &rhs || Set::lexicographical_equal(lhs, rhs);
}
@@ -306,15 +306,15 @@
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
Modified: sandbox/itl/boost/itl/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/interval_set_algo.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -29,7 +29,7 @@
size_type interval_size;
const_FORALL(typename IntervalContainerT, it, object)
{
- interval_size = continuous_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
+ interval_size = continuous_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
if(interval_size == std::numeric_limits<size_type>::infinity())
return interval_size;
else
@@ -46,7 +46,7 @@
size_type size = neutron<size_type>::value();
const_FORALL(typename IntervalContainerT, it, object)
- size += discrete_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
+ size += discrete_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
return size;
}
@@ -77,34 +77,34 @@
template<class LeftT, class RightT>
bool is_element_equal(const LeftT& left, const RightT& right)
{
- return subset_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- ) == inclusion::equal;
+ return subset_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ ) == inclusion::equal;
}
template<class LeftT, class RightT>
bool is_element_less(const LeftT& left, const RightT& right)
{
- return element_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- ) == comparison::less;
+ return element_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ ) == comparison::less;
}
template<class LeftT, class RightT>
bool is_element_greater(const LeftT& left, const RightT& right)
{
- return element_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- ) == comparison::greater;
+ return element_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ ) == comparison::greater;
}
//------------------------------------------------------------------------------
@@ -114,38 +114,38 @@
template<class LeftT, class RightT>
bool is_inclusion_equal(const LeftT& left, const RightT& right)
{
- return subset_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- ) == inclusion::equal;
+ return subset_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ ) == inclusion::equal;
}
template<class LeftT, class RightT>
bool is_contained_in(const LeftT& left, const RightT& right)
{
- int result =
- subset_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- );
- return result == inclusion::subset || result == inclusion::equal;
+ int result =
+ subset_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ );
+ return result == inclusion::subset || result == inclusion::equal;
}
template<class LeftT, class RightT>
bool contains(const LeftT& left, const RightT& right)
{
- int result =
- subset_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- );
- return result == inclusion::superset || result == inclusion::equal;
+ int result =
+ subset_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ );
+ return result == inclusion::superset || result == inclusion::equal;
}
} // namespace Interval_Set
Modified: sandbox/itl/boost/itl/interval_sets.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_sets.hpp (original)
+++ sandbox/itl/boost/itl/interval_sets.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -36,7 +36,7 @@
const IntervalSet <DomainT,Compare,Interval,Alloc>& right
)
{
- return Interval_Set::is_element_equal(left, right);
+ return Interval_Set::is_element_equal(left, right);
}
template
@@ -51,7 +51,7 @@
const IntervalSet <DomainT,Compare,Interval,Alloc>& right
)
{
- return Interval_Set::is_element_less(left, right);
+ return Interval_Set::is_element_less(left, right);
}
template
@@ -66,7 +66,7 @@
const IntervalSet <DomainT,Compare,Interval,Alloc>& right
)
{
- return Interval_Set::is_element_greater(left, right);
+ return Interval_Set::is_element_greater(left, right);
}
//-----------------------------------------------------------------------------
@@ -74,7 +74,7 @@
//-----------------------------------------------------------------------------
template
<
- class ObjectT,
+ class ObjectT,
class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
@@ -97,7 +97,7 @@
template
<
class ObjectT,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
ObjectT& operator -=
@@ -116,13 +116,13 @@
template
<
class ObjectT,
- class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+ class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
ObjectT& operator ^=
- (ObjectT& object, const IntervalSet<DomainT,Compare,Interval,Alloc>& operand)
+ (ObjectT& object, const IntervalSet<DomainT,Compare,Interval,Alloc>& operand)
{
- return object.flip(operand);
+ return object.flip(operand);
}
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -71,7 +71,7 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
ITL_ALLOC Alloc = std::allocator
>
class map: private std::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
@@ -98,10 +98,10 @@
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
typedef domain_compare key_compare;
- typedef typename inverse<codomain_combine >::type inverse_codomain_combine;
- typedef ITL_SECTION_CODOMAIN(Section,CodomainT) codomain_intersect;
- typedef typename inverse<codomain_intersect>::type inverse_codomain_intersect;
- typedef typename base_type::value_compare value_compare;
+ typedef typename inverse<codomain_combine >::type inverse_codomain_combine;
+ typedef ITL_SECTION_CODOMAIN(Section,CodomainT) codomain_intersect;
+ typedef typename inverse<codomain_intersect>::type inverse_codomain_intersect;
+ typedef typename base_type::value_compare value_compare;
public:
typedef typename base_type::pointer pointer;
@@ -115,12 +115,12 @@
typedef typename base_type::reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator;
- enum { fineness = 4 };
+ enum { fineness = 4 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
map(){}
map(const key_compare& comp): base_type(comp){}
@@ -137,8 +137,8 @@
map& operator=(const map& src) { base_type::operator=(src); return *this; }
void swap(map& src) { base_type::swap(src); }
- //==========================================================================
- using base_type::empty;
+ //==========================================================================
+ using base_type::empty;
using base_type::clear;
using base_type::begin;
@@ -165,12 +165,12 @@
public:
inline static bool has_symmetric_difference()
- { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }
+ { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }
public:
- //==========================================================================
- //= Emptieness, containment
- //==========================================================================
+ //==========================================================================
+ //= Emptieness, containment
+ //==========================================================================
/** Checks if a key element is in the map */
bool contains(const DomainT& x)const { return !(find(x) == end()); }
@@ -183,9 +183,9 @@
bool contains(const map& sub)const
{ return Map::contained_in(sub, *this); }
- //==========================================================================
- //= Size
- //==========================================================================
+ //==========================================================================
+ //= Size
+ //==========================================================================
/** \c iterative_size() yields the number of elements that is visited
throu complete iteration. For interval sets \c iterative_size() is
different from \c size(). */
@@ -200,21 +200,21 @@
else
return base_type::insert(value_pair);
}
- //==========================================================================
- //= Selection
- //==========================================================================
-
- /** Total select function. */
- codomain_type operator()(const domain_type& key)const
- {
+ //==========================================================================
+ //= Selection
+ //==========================================================================
+
+ /** Total select function. */
+ codomain_type operator()(const domain_type& key)const
+ {
const_iterator it = find(key);
- return it==end() ? neutron<codomain_type>::value()
- : it->CONT_VALUE;
- }
-
- //==========================================================================
- //= Addition, subtraction
- //==========================================================================
+ return it==end() ? neutron<codomain_type>::value()
+ : it->CONT_VALUE;
+ }
+
+ //==========================================================================
+ //= Addition, subtraction
+ //==========================================================================
/** \c add inserts \c value_pair into the map if it's key does
not exist in the map.
If \c value_pairs's key value exists in the map, it's data
@@ -224,72 +224,72 @@
/** If the \c value_pair's key value is in the map, it's data value is
subtraced from the data value stored in the map. */
map& subtract(const value_type& value_pair)
- {
- if(Traits::is_total && has_inverse<codomain_type>::value)
- this->template add<inverse_codomain_combine>(value_pair);
- else
- this->template subtract<inverse_codomain_combine>(value_pair);
+ {
+ if(Traits::is_total && has_inverse<codomain_type>::value)
+ this->template add<inverse_codomain_combine>(value_pair);
+ else
+ this->template subtract<inverse_codomain_combine>(value_pair);
- return *this;
- }
+ return *this;
+ }
- //==========================================================================
- //= Insertion, erasure
- //==========================================================================
+ //==========================================================================
+ //= Insertion, erasure
+ //==========================================================================
/** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
- map& set(const element_type& key_value_pair)
- { (*this)[key_value_pair.KEY_VALUE] = key_value_pair.CONT_VALUE; return *this; }
+ map& set(const element_type& key_value_pair)
+ { (*this)[key_value_pair.KEY_VALUE] = key_value_pair.CONT_VALUE; return *this; }
/** erase the value pair \c pair(key,val) from the map.
Erase only if, the exact value content \c val is stored at key \key. */
size_type erase(const value_type& value);
- //==========================================================================
- //= Intersection
- //==========================================================================
+ //==========================================================================
+ //= Intersection
+ //==========================================================================
- /** The intersection of \c key in \c *this map is added to \c section. */
- void add_intersection(map& section, const domain_type& key_value)const;
+ /** The intersection of \c key in \c *this map is added to \c section. */
+ void add_intersection(map& section, const domain_type& key_value)const;
- /** The intersection of \c key_value_pair and \c *this map is added to \c section. */
- void add_intersection(map& section, const element_type& key_value_pair)const;
+ /** The intersection of \c key_value_pair and \c *this map is added to \c section. */
+ void add_intersection(map& section, const element_type& key_value_pair)const;
- /** The intersection of set \c sectant with \c *this map is added to \c section. */
- void add_intersection(map& section, const set_type& sectant)const;
+ /** The intersection of set \c sectant with \c *this map is added to \c section. */
+ void add_intersection(map& section, const set_type& sectant)const;
- /** The intersection of map \c sectant with \c *this map is added to \c section. */
- void add_intersection(map& section, const map& sectant)const;
+ /** The intersection of map \c sectant with \c *this map is added to \c section. */
+ void add_intersection(map& section, const map& sectant)const;
- //==========================================================================
- //= Symmetric difference
- //==========================================================================
+ //==========================================================================
+ //= Symmetric difference
+ //==========================================================================
- map& flip(const element_type& key_value_pair)
- { Map::flip(*this, map(key_value_pair)); return *this; }
+ map& flip(const element_type& key_value_pair)
+ { Map::flip(*this, map(key_value_pair)); return *this; }
- //==========================================================================
- //= Morphisms
- //==========================================================================
-
- void absorb_neutrons()
+ //==========================================================================
+ //= Morphisms
+ //==========================================================================
+
+ void absorb_neutrons()
{
//content_is_neutron<key_type, data_type> neutron_dropper;
if(!Traits::absorbs_neutrons)
erase_if(content_is_neutron<value_type>());
}
- //==========================================================================
- //= Representaion
- //==========================================================================
-
+ //==========================================================================
+ //= Representaion
+ //==========================================================================
+
/** Represent this map as string */
std::string as_string()const;
- //==========================================================================
- //= Algorithm unifiers
- //==========================================================================
+ //==========================================================================
+ //= Algorithm unifiers
+ //==========================================================================
/** \c key_value allows for a uniform access to \c key_values which is
is used for common algorithms on sets and maps. */
@@ -361,7 +361,7 @@
if(Traits::absorbs_neutrons && (*it).CONT_VALUE == Combiner::neutron())
erase(it);
- return *this;
+ return *this;
}
}
@@ -402,76 +402,76 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const value_type& sectant)const
+ ::add_intersection(map& section, const value_type& sectant)const
{
- if(Traits::is_total)
- {
- section = *this;
- section.add(sectant);
- }
- else
- {
- const_iterator it_ = find(sectant.KEY_VALUE);
- if(it_ != end())
- {
- section.add(*it_);
- if(is_set<CodomainT>::value)
- section.template add<codomain_intersect>(sectant);
- else
- section.template add<codomain_combine>(sectant);
- }
- }
+ if(Traits::is_total)
+ {
+ section = *this;
+ section.add(sectant);
+ }
+ else
+ {
+ const_iterator it_ = find(sectant.KEY_VALUE);
+ if(it_ != end())
+ {
+ section.add(*it_);
+ if(is_set<CodomainT>::value)
+ section.template add<codomain_intersect>(sectant);
+ else
+ section.template add<codomain_combine>(sectant);
+ }
+ }
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const domain_type& sectant)const
+ ::add_intersection(map& section, const domain_type& sectant)const
{
- const_iterator it_ = find(sectant);
- if(it_ != end())
- section.add(*it_);
+ const_iterator it_ = find(sectant);
+ if(it_ != end())
+ section.add(*it_);
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const typename map::set_type& sectant)const
+ ::add_intersection(map& section, const typename map::set_type& sectant)const
{
typename set_type::const_iterator common_lwb_;
typename set_type::const_iterator common_upb_;
if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
return;
- typename set_type::const_iterator sec_ = common_lwb_;
- while(sec_ != common_upb_)
- add_intersection(section, *sec_++);
+ typename set_type::const_iterator sec_ = common_lwb_;
+ while(sec_ != common_upb_)
+ add_intersection(section, *sec_++);
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const map& sectant)const
+ ::add_intersection(map& section, const map& sectant)const
{
const_iterator common_lwb_;
const_iterator common_upb_;
- if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
+ if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
return;
- const_iterator sec_ = common_lwb_;
- while(sec_ != common_upb_)
- {
- const_iterator it_ = find(sec_->KEY_VALUE);
- if(it_ != end())
- {
- section.add(*it_);
- if(is_set<CodomainT>::value)
- section.template add<codomain_intersect>(*sec_);
- else
- section.template add<codomain_combine>(*sec_);
- }
- ++sec_;
- }
+ const_iterator sec_ = common_lwb_;
+ while(sec_ != common_upb_)
+ {
+ const_iterator it_ = find(sec_->KEY_VALUE);
+ if(it_ != end())
+ {
+ section.add(*it_);
+ if(is_set<CodomainT>::value)
+ section.template add<codomain_intersect>(*sec_);
+ else
+ section.template add<codomain_combine>(*sec_);
+ }
+ ++sec_;
+ }
}
@@ -583,7 +583,7 @@
inline bool is_protonic_equal (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
{
- return Map::lexicographical_protonic_equal(lhs, rhs);
+ return Map::lexicographical_protonic_equal(lhs, rhs);
}
/** Strict weak less ordering which is given by the Compare order */
@@ -623,8 +623,8 @@
operator + ( const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::value_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) += operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) += operand;
}
@@ -642,8 +642,8 @@
operator + (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) += operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) += operand;
}
//--------------------------------------------------------------------------
@@ -659,8 +659,8 @@
operator | ( const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::value_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) |= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) |= operand;
}
@@ -678,8 +678,8 @@
operator | (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) |= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) |= operand;
}
//--------------------------------------------------------------------------
@@ -691,9 +691,9 @@
operator -= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
const_FORALL(typename ObjectT, it_, operand)
- object.subtract(*it_);
+ object.subtract(*it_);
return object;
}
@@ -703,8 +703,8 @@
operator - (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) -= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
}
/** Subtract a set \c x2 from this map. Every element of \c this map that
@@ -721,8 +721,8 @@
operator - (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) -= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
}
@@ -733,15 +733,15 @@
operator &= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object_type;
- if(Traits::is_total) return object += operand;
- else
- {
- object_type section;
- object.add_intersection(section, operand);
- object.swap(section);
- return object;
- }
+ typedef typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object_type;
+ if(Traits::is_total) return object += operand;
+ else
+ {
+ object_type section;
+ object.add_intersection(section, operand);
+ object.swap(section);
+ return object;
+ }
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
@@ -749,8 +749,8 @@
operator & (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) &= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) &= operand;
}
/** Intersect set \c x2 and \c *this.
@@ -767,8 +767,8 @@
operator & (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) &= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) &= operand;
}
@@ -779,8 +779,8 @@
operator ^= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- Map::flip(object, operand);
- return object;
+ Map::flip(object, operand);
+ return object;
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
@@ -788,24 +788,24 @@
operator ^ (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- return ObjectT(object) ^= operand;
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ return ObjectT(object) ^= operand;
}
//---------------------------------------------------------------------------------
template<class CharType, class CharTraits,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- stream << "{";
- const_FORALL(typename ObjectT, it, object)
- stream << "(" << it->KEY_VALUE << "->" << it->CONT_VALUE << ")";
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
+ stream << "{";
+ const_FORALL(typename ObjectT, it, object)
+ stream << "(" << it->KEY_VALUE << "->" << it->CONT_VALUE << ")";
- return stream << "}";
+ return stream << "}";
}
@@ -815,29 +815,29 @@
template<class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct is_map<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef is_map<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = true;
+ typedef is_map<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct has_inverse<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef has_inverse<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ typedef has_inverse<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
+ static const bool value = has_inverse<CodomainT>::value;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- enum{value = true};
+ typedef is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
+ enum{value = true};
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
Modified: sandbox/itl/boost/itl/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/map_algo.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -62,7 +62,7 @@
{
result.insert(*x1_);
if(is_set<typename MapType::codomain_type>::value)
- result.template add<MapType::codomain_intersect>(*x2_); //MEMO template cast for gcc
+ result.template add<MapType::codomain_intersect>(*x2_); //MEMO template cast for gcc
else
result.template add<MapType::codomain_combine>(*x2_);
}
@@ -112,82 +112,82 @@
}
//----------------------------------------------------------------------
- // flip
+ // flip
//----------------------------------------------------------------------
template<class MapType>
void flip(MapType& result, const MapType& x2)
{
- if(is_total<MapType>::value && absorbs_neutrons<MapType>::value)
- {
- result.clear();
- return;
- }
+ if(is_total<MapType>::value && absorbs_neutrons<MapType>::value)
+ {
+ result.clear();
+ return;
+ }
typename MapType::const_iterator x2_ = x2.begin(), cur_x2_, x1_;
while(x2_ != x2.end())
- {
- cur_x2_ = x2_;
- std::pair<typename MapType::iterator,bool> insertion
- = result.insert(*x2_++);
- if(!insertion.WAS_SUCCESSFUL)
- {
- //result.erase(insertion.ITERATOR);
- if(is_set<typename MapType::codomain_type>::value)
- {
- typename MapType::iterator res_ = insertion.ITERATOR;
- typename MapType::codomain_type common_value = res_->CONT_VALUE;
- MapType::inverse_codomain_intersect()(common_value, cur_x2_->CONT_VALUE);
- result.subtract(*res_);
- result.add(MapType::value_type(res_->KEY_VALUE, common_value));
- }
+ {
+ cur_x2_ = x2_;
+ std::pair<typename MapType::iterator,bool> insertion
+ = result.insert(*x2_++);
+ if(!insertion.WAS_SUCCESSFUL)
+ {
+ //result.erase(insertion.ITERATOR);
+ if(is_set<typename MapType::codomain_type>::value)
+ {
+ typename MapType::iterator res_ = insertion.ITERATOR;
+ typename MapType::codomain_type common_value = res_->CONT_VALUE;
+ MapType::inverse_codomain_intersect()(common_value, cur_x2_->CONT_VALUE);
+ result.subtract(*res_);
+ result.add(MapType::value_type(res_->KEY_VALUE, common_value));
+ }
else
result.subtract(*insertion.ITERATOR);
- }
- }
+ }
+ }
- if(is_total<MapType>::value && !absorbs_neutrons<MapType>::value)
- FORALL(typename MapType, it_, result)
- it_->CONT_VALUE = neutron<typename MapType::codomain_type>::value();
+ if(is_total<MapType>::value && !absorbs_neutrons<MapType>::value)
+ FORALL(typename MapType, it_, result)
+ it_->CONT_VALUE = neutron<typename MapType::codomain_type>::value();
}
- template<class MapType>
- typename MapType::const_iterator next_proton(typename MapType::const_iterator& iter_, const MapType& object)
- {
- while( iter_ != object.end()
- && iter_->CONT_VALUE == neutron<typename MapType::codomain_type>::value())
- ++iter_;
+ template<class MapType>
+ typename MapType::const_iterator next_proton(typename MapType::const_iterator& iter_, const MapType& object)
+ {
+ while( iter_ != object.end()
+ && iter_->CONT_VALUE == neutron<typename MapType::codomain_type>::value())
+ ++iter_;
- return iter_;
- }
+ return iter_;
+ }
- /** Function template <tt>lexicographical_equal</tt> implements
+ /** Function template <tt>lexicographical_equal</tt> implements
lexicographical equality except for neutronic content values. */
template<class MapType>
- bool lexicographical_protonic_equal(const MapType& left, const MapType& right)
+ bool lexicographical_protonic_equal(const MapType& left, const MapType& right)
{
if(&left == &right)
- return true;
+ return true;
typename MapType::const_iterator left_ = left.begin();
typename MapType::const_iterator right_ = right.begin();
- left_ = next_proton(left_, left);
- right_ = next_proton(right_, right);
+ left_ = next_proton(left_, left);
+ right_ = next_proton(right_, right);
while(left_ != left.end() && right_ != right.end())
{
if(!(left_->KEY_VALUE == right_->KEY_VALUE && left_->CONT_VALUE == right_->CONT_VALUE))
return false;
- ++left_;
- ++right_;
- left_ = next_proton(left_, left);
- right_ = next_proton(right_, right);
+ ++left_;
+ ++right_;
+ left_ = next_proton(left_, left);
+ right_ = next_proton(right_, right);
}
- return left_ == left.end() && right_ == right.end();
+ return left_ == left.end() && right_ == right.end();
}
Modified: sandbox/itl/boost/itl/operators.hpp
==============================================================================
--- sandbox/itl/boost/itl/operators.hpp (original)
+++ sandbox/itl/boost/itl/operators.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -102,7 +102,7 @@
{
ObjectT intersection;
object.add_intersection(intersection, operand);
- object.swap(intersection);
+ object.swap(intersection);
return object;
}
Modified: sandbox/itl/boost/itl/ptime.hpp
==============================================================================
--- sandbox/itl/boost/itl/ptime.hpp (original)
+++ sandbox/itl/boost/itl/ptime.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/boost/itl/rational.hpp
==============================================================================
--- sandbox/itl/boost/itl/rational.hpp (original)
+++ sandbox/itl/boost/itl/rational.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -34,7 +34,7 @@
DomainT,Compare,Interval,Alloc> base_type;
typedef separate_interval_set<DomainT,Compare,Interval,Alloc> type;
- typedef type overloadable_type;
+ typedef type overloadable_type;
typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
@@ -83,12 +83,12 @@
typedef typename ImplSetT::const_iterator const_iterator;
- enum { fineness = 2 };
+ enum { fineness = 2 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/// Default constructor for the empty object
separate_interval_set(): base_type() {}
/// Copy constructor
@@ -123,8 +123,8 @@
}
private:
- friend class
- interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
+ friend class
+ interval_base_set<separate_interval_set<DomainT,Compare,Interval,Alloc>,
DomainT,Compare,Interval,Alloc>;
/// Does the set contain the interval <tt>x</tt>?
@@ -215,22 +215,22 @@
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -63,23 +63,23 @@
typedef typename base_type::reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator;
- enum { fineness = 4 };
+ enum { fineness = 4 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
set(){}
set(const domain_compare& comp):
std::set<DomainT, domain_compare, Alloc<DomainT> >(comp){}
template <class InputIterator>
set(InputIterator first, InputIterator last):
- std::set<InputIterator>(first,last) {}
+ std::set<InputIterator>(first,last) {}
template <class InputIterator>
set(InputIterator first, InputIterator last, const key_compare& comp):
- std::set<InputIterator>(first, last, comp) {}
+ std::set<InputIterator>(first, last, comp) {}
set(const set& src): base_type::set(src){}
@@ -93,7 +93,7 @@
template<class Predicate>
set& assign_if(const set& src, const Predicate&);
- //==========================================================================
+ //==========================================================================
using base_type::empty;
using base_type::clear;
@@ -118,75 +118,75 @@
using base_type::equal_range;
public:
- //==========================================================================
- //= Emptieness, containment
- //==========================================================================
+ //==========================================================================
+ //= Emptieness, containment
+ //==========================================================================
/// Checks if the element \c value is in the set
bool contains(const element_type& value)const
- { return !(find(value) == end()); }
+ { return !(find(value) == end()); }
/** Is <tt>*this</tt> contained in <tt>super</tt>? */
bool contained_in(const set& super)const
- { return Set::contained_in(*this, super); }
+ { return Set::contained_in(*this, super); }
/** Does <tt>*this</tt> contain <tt>sub</tt>? */
bool contains(const set& sub)const { return Set::contained_in(sub, *this); }
/** <tt>*this</tt> and <tt>x2</tt> are disjoint, if their intersection is empty */
- bool disjoint(const set& x2)const { return Set::disjoint(*this, x2); }
+ bool disjoint(const set& x2)const { return Set::disjoint(*this, x2); }
- //==========================================================================
- //= Size
- //==========================================================================
+ //==========================================================================
+ //= Size
+ //==========================================================================
/** \c iterative_size() yields the number of elements that is visited
throu complete iteration. For interval sets \c iterative_size() is
different from \c size(). */
size_t iterative_size()const { return size(); }
- size_t cardinality()const { return size(); }
+ size_t cardinality()const { return size(); }
- //==========================================================================
- //= Addition, subtraction
- //==========================================================================
- /** Add an element \c value to the set. */
+ //==========================================================================
+ //= Addition, subtraction
+ //==========================================================================
+ /** Add an element \c value to the set. */
set& add(const element_type& value) { insert(value); return *this; }
- /** Subtract an element \c value from the set. */
+ /** Subtract an element \c value from the set. */
set& subtract(const element_type& value);
- //==========================================================================
- //= Insertion, erasure
- //==========================================================================
+ //==========================================================================
+ //= Insertion, erasure
+ //==========================================================================
/** Erase the elements in *this set to which property \c hasProperty applies.
Keep all the rest. */
template<class Predicate>
set& erase_if(const Predicate&);
- //==========================================================================
- //= Intersection, symmetric difference
- //==========================================================================
-
- /** The intersection of \c key in \c *this set is added to \c section. */
- void add_intersection(set& section, const element_type& key)const;
-
- /** The intersection of set \c sectant with \c *this set is added
- to \c section. */
- void add_intersection(set& section, const set& sectant)const;
+ //==========================================================================
+ //= Intersection, symmetric difference
+ //==========================================================================
+
+ /** The intersection of \c key in \c *this set is added to \c section. */
+ void add_intersection(set& section, const element_type& key)const;
+
+ /** The intersection of set \c sectant with \c *this set is added
+ to \c section. */
+ void add_intersection(set& section, const set& sectant)const;
- /** If \c *this set contains \c value it is erased, otherwise it is added. */
+ /** If \c *this set contains \c value it is erased, otherwise it is added. */
set& flip(const element_type& value);
- //==========================================================================
- //= Representation
- //==========================================================================
+ //==========================================================================
+ //= Representation
+ //==========================================================================
/** Represent this set as a string */
std::string as_string(const char* sep = " ")const;
- //==========================================================================
- //= Algorithm unifiers
- //==========================================================================
+ //==========================================================================
+ //= Algorithm unifiers
+ //==========================================================================
/** \c key_value allows for a uniform access to \c key_values which is
is used for common algorithms on sets and maps. */
@@ -226,36 +226,36 @@
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
void set<DomainT,Compare,Alloc>
- ::add_intersection(set& section, const element_type§ant)const
+ ::add_intersection(set& section, const element_type§ant)const
{
- const_iterator it_ = find(sectant);
- if(it_ != end())
- section.add(*it_);
+ const_iterator it_ = find(sectant);
+ if(it_ != end())
+ section.add(*it_);
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
void set<DomainT,Compare,Alloc>
- ::add_intersection(set& section, const set& sectant)const
+ ::add_intersection(set& section, const set& sectant)const
{
const_iterator common_lwb_;
const_iterator common_upb_;
- if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
+ if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
return;
- const_iterator sec_ = common_lwb_;
- while(sec_ != common_upb_)
- add_intersection(section, *sec_++);
+ const_iterator sec_ = common_lwb_;
+ while(sec_ != common_upb_)
+ add_intersection(section, *sec_++);
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
inline itl::set<DomainT,Compare,Alloc>&
set<DomainT,Compare,Alloc>::flip(const element_type& operand)
{
- std::pair<iterator,bool> insertion = insert(operand);
- if(!insertion.WAS_SUCCESSFUL)
- erase(insertion.ITERATOR);
+ std::pair<iterator,bool> insertion = insert(operand);
+ if(!insertion.WAS_SUCCESSFUL)
+ erase(insertion.ITERATOR);
- return *this;
+ return *this;
}
@@ -447,10 +447,10 @@
operator &= ( itl::set<DomainT,Compare,Alloc>& object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- itl::set<DomainT,Compare,Alloc> section;
- object.add_intersection(section, operand);
- object.swap(section);
- return object;
+ itl::set<DomainT,Compare,Alloc> section;
+ object.add_intersection(section, operand);
+ object.swap(section);
+ return object;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
@@ -468,10 +468,10 @@
operator &= ( itl::set<DomainT,Compare,Alloc>& object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- itl::set<DomainT,Compare,Alloc> section;
- object.add_intersection(section, operand);
- object.swap(section);
- return object;
+ itl::set<DomainT,Compare,Alloc> section;
+ object.add_intersection(section, operand);
+ object.swap(section);
+ return object;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
@@ -488,7 +488,7 @@
operator ^= ( itl::set<DomainT,Compare,Alloc>& object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- return object.flip(operand);
+ return object.flip(operand);
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
@@ -496,7 +496,7 @@
operator ^ (const itl::set<DomainT,Compare,Alloc>& object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- return itl::set<DomainT,Compare,Alloc>(object) ^= operand;
+ return itl::set<DomainT,Compare,Alloc>(object) ^= operand;
}
@@ -508,7 +508,7 @@
operator ^= ( itl::set<DomainT,Compare,Alloc>& object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- Set::flip(object, operand); return object;
+ Set::flip(object, operand); return object;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
@@ -516,7 +516,7 @@
operator ^ (const itl::set<DomainT,Compare,Alloc>& object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- return itl::set<DomainT,Compare,Alloc>(object) ^= operand;
+ return itl::set<DomainT,Compare,Alloc>(object) ^= operand;
}
@@ -536,17 +536,17 @@
//---------------------------------------------------------------------------------
template<class CharType, class CharTraits,
- class DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+ class DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
const itl::set<DomainT,Compare,Alloc>& object)
{
- typedef itl::set<DomainT,Compare,Alloc> ObjectT;
- stream << "{";
- const_FORALL(typename ObjectT, it, object)
- stream << *it;
+ typedef itl::set<DomainT,Compare,Alloc> ObjectT;
+ stream << "{";
+ const_FORALL(typename ObjectT, it, object)
+ stream << *it;
- return stream << "}";
+ return stream << "}";
}
@@ -554,15 +554,15 @@
template <class Type>
struct is_set<itl::set<Type> >
{
- typedef is_set<itl::set<Type> > type;
- static const bool value = true;
+ typedef is_set<itl::set<Type> > type;
+ static const bool value = true;
};
template <class Type>
struct is_interval_container<itl::set<Type> >
{
- typedef is_interval_container<itl::set<Type> > type;
- enum{value = true};
+ typedef is_interval_container<itl::set<Type> > type;
+ enum{value = true};
};
template <class Type>
Modified: sandbox/itl/boost/itl/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/set_algo.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -193,16 +193,16 @@
}
- template<class SetType>
+ template<class SetType>
void flip(SetType& result, const SetType& x2)
{
typename SetType::const_iterator x2_ = x2.begin(), x1_;
while(x2_ != x2.end())
- {
- std::pair<typename SetType::iterator,bool> insertion = result.insert(*x2_++);
- if(!insertion.WAS_SUCCESSFUL)
- result.erase(insertion.ITERATOR);
- }
+ {
+ std::pair<typename SetType::iterator,bool> insertion = result.insert(*x2_++);
+ if(!insertion.WAS_SUCCESSFUL)
+ result.erase(insertion.ITERATOR);
+ }
}
Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -26,8 +26,8 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
- template<class,ITL_COMPARE>class Interval = itl::interval,
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
class split_interval_map:
@@ -38,7 +38,7 @@
typedef Traits traits;
typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> joint_type;
- typedef type overloadable_type;
+ typedef type overloadable_type;
typedef interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
@@ -57,12 +57,12 @@
typedef interval_set<DomainT,Compare,Interval,Alloc> interval_set_type;
typedef interval_set_type set_type;
- enum { fineness = 3 };
+ enum { fineness = 3 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/// Default constructor for the empty object
split_interval_map(): base_type() {}
/// Copy constructor
@@ -94,26 +94,26 @@
this->_map.insert(*it);
}
- //==========================================================================
- //= Selection
- //==========================================================================
-
- //MEMO DESIGN DECISION: split_interval_map::operator[](interval):
- // If used for selection will deliver a set of associated
- // values. It could only implemented for a single key value. But this
- // would mislead the unexperienced user to hash a split_interval_map into
- // singular intervals by inapt usage of op[]. So op[] will not be implemented
- // codomain_type& operator[](const interval_type& interval_of_keys)
+ //==========================================================================
+ //= Selection
+ //==========================================================================
+
+ //MEMO DESIGN DECISION: split_interval_map::operator[](interval):
+ // If used for selection will deliver a set of associated
+ // values. It could only implemented for a single key value. But this
+ // would mislead the unexperienced user to hash a split_interval_map into
+ // singular intervals by inapt usage of op[]. So op[] will not be implemented
+ // codomain_type& operator[](const interval_type& interval_of_keys)
private:
- // The following _suffixed function templates funx_ are implementations
- // correspoding unsuffixed function templates funx of the base class.
- // For funx_ want to be used in the base class via derived SubType pointer:
- // that()->funx_. So they must be either public or made accessible by a
- // friend declaration:
+ // The following _suffixed function templates funx_ are implementations
+ // correspoding unsuffixed function templates funx of the base class.
+ // For funx_ want to be used in the base class via derived SubType pointer:
+ // that()->funx_. So they must be either public or made accessible by a
+ // friend declaration:
friend class
- interval_base_map
- <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
+ interval_base_map
+ <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>,
DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc >;
bool contains_(const value_type& x)const;
@@ -141,11 +141,11 @@
template<class Combiner>
void add_rear(const interval_type& x_itv, const CodomainT& x_val,
- iterator& it);
+ iterator& it);
template<class Combiner>
void subtract_rest(const interval_type& x_itv, const CodomainT& x_val,
- iterator& it, iterator& end_it);
+ iterator& it, iterator& end_it);
void insert_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it);
void insert_rear(const interval_type& x_itv, const CodomainT& x_val, iterator& it);
@@ -199,9 +199,9 @@
{
CodomainT added_val = Combiner::neutron();
Combiner()(added_val, value.CONT_VALUE);
- if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
- return;
- else
+ if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
+ return;
+ else
this->_map.insert(value_type(value.KEY_VALUE, added_val));
}
else
@@ -230,10 +230,10 @@
{
CodomainT added_val = Combiner::neutron();
Combiner()(added_val, x_val);
- if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
- return;
- else
- insertion = this->_map.insert(value_type(x_itv, added_val));
+ if(Traits::absorbs_neutrons && added_val == Combiner::neutron())
+ return;
+ else
+ insertion = this->_map.insert(value_type(x_itv, added_val));
}
else
insertion = this->_map.insert(x);
@@ -475,7 +475,7 @@
return;
const CodomainT& x_val = x.CONT_VALUE;
- if(Traits::absorbs_neutrons && x_val == codomain_combine::neutron())
+ if(Traits::absorbs_neutrons && x_val == codomain_combine::neutron())
return;
std::pair<typename ImplMapT::iterator,bool>
@@ -666,50 +666,50 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- enum{value = true};
+ typedef is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ enum{value = true};
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = has_inverse<CodomainT>::value;
+ typedef has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = has_inverse<CodomainT>::value;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::absorbs_neutrons;
+ typedef absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = Traits::absorbs_neutrons;
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- static const bool value = Traits::is_total;
+ typedef is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ static const bool value = Traits::is_total;
};
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -33,15 +33,15 @@
typedef split_interval_set<DomainT,Compare,Interval,Alloc> type;
typedef interval_set<DomainT,Compare,Interval,Alloc> joint_type;
- typedef type overloadable_type;
+ typedef type overloadable_type;
/// The domain type of the set
typedef DomainT domain_type;
/// The codomaintype is the same as domain_type
typedef DomainT codomain_type;
- /// The element type of the set
- typedef DomainT element_type;
+ /// The element type of the set
+ typedef DomainT element_type;
/// The interval type of the set
typedef Interval<DomainT,Compare> interval_type;
/// The segment type of the set
@@ -79,12 +79,12 @@
/// const_iterator for iteration over intervals
typedef typename ImplSetT::const_iterator const_iterator;
- enum { fineness = 3 };
+ enum { fineness = 3 };
public:
- //==========================================================================
- //= Construct, copy, destruct
- //==========================================================================
+ //==========================================================================
+ //= Construct, copy, destruct
+ //==========================================================================
/// Default constructor for the empty object
split_interval_set(): base_type() {}
@@ -120,9 +120,9 @@
}
private:
- friend class
- interval_base_set<split_interval_set<DomainT,Compare,Interval,Alloc>,
- DomainT,Compare,Interval,Alloc>;
+ friend class
+ interval_base_set<split_interval_set<DomainT,Compare,Interval,Alloc>,
+ DomainT,Compare,Interval,Alloc>;
/// Does the set contain the interval <tt>x</tt>?
bool contains_(const interval_type& x)const;
@@ -355,22 +355,22 @@
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
template <class DomainT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
struct is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
- static const bool value = true;
+ typedef is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ static const bool value = true;
};
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -11,10 +11,10 @@
namespace boost{ namespace itl
{
template <class Type> struct absorbs_neutrons
- {
- typedef absorbs_neutrons<Type> type;
- static const bool value = false;
- };
+ {
+ typedef absorbs_neutrons<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/difference.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/difference.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/difference.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/boost/itl/type_traits/has_inverse.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/has_inverse.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/has_inverse.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_has_inverse_JOFA_090205_H__
#define __itl_type_traits_has_inverse_JOFA_090205_H__
@@ -14,10 +14,10 @@
{
template <class Type> struct has_inverse
- {
- typedef has_inverse<Type> type;
- static const bool value = is_signed<Type>::value;
- };
+ {
+ typedef has_inverse<Type> type;
+ static const bool value = is_signed<Type>::value;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_is_combinable_JOFA_090115_H__
#define __itl_is_combinable_JOFA_090115_H__
@@ -21,26 +21,26 @@
template<class Type>
struct is_overloadable
{
- typedef is_overloadable<Type> type;
- static const bool value =
- is_same<Type, typename Type::overloadable_type>::value;
+ typedef is_overloadable<Type> type;
+ static const bool value =
+ is_same<Type, typename Type::overloadable_type>::value;
};
template<class Type>
struct is_interval_map
{
- typedef is_interval_map<Type> type;
- static const bool value =
- is_interval_container<Type>::value && is_map<Type>::value;
+ typedef is_interval_map<Type> type;
+ static const bool value =
+ is_interval_container<Type>::value && is_map<Type>::value;
};
template<class Type>
struct is_interval_set
{
- typedef is_interval_set<Type> type;
- static const bool value =
- is_interval_container<Type>::value && !is_interval_map<Type>::value;
+ typedef is_interval_set<Type> type;
+ static const bool value =
+ is_interval_container<Type>::value && !is_interval_map<Type>::value;
};
@@ -53,7 +53,7 @@
template<class Type>
struct is_interval_set_derivative<Type, typename Type::domain_type>
{
- static const bool value = is_interval_container<Type>::value;
+ static const bool value = is_interval_container<Type>::value;
};
template<class Type>
@@ -63,7 +63,7 @@
template<class Type, class AssociateT>
struct is_interval_set_derivative
{
- enum{ value = false };
+ enum{ value = false };
};
//------------------------------------------------------------------------------
@@ -75,29 +75,29 @@
template<class Type>
struct is_interval_map_derivative<Type, typename Type::domain_mapping_type>
{
- typedef is_interval_map_derivative<Type, typename Type::domain_mapping_type> type;
- static const bool value = is_interval_container<Type>::value;
+ typedef is_interval_map_derivative<Type, typename Type::domain_mapping_type> type;
+ static const bool value = is_interval_container<Type>::value;
};
template<class Type>
struct is_interval_map_derivative<Type, typename Type::interval_mapping_type>
{
- typedef is_interval_map_derivative<Type, typename Type::interval_mapping_type> type;
- static const bool value = is_interval_container<Type>::value;
+ typedef is_interval_map_derivative<Type, typename Type::interval_mapping_type> type;
+ static const bool value = is_interval_container<Type>::value;
};
template<class Type>
struct is_interval_map_derivative<Type, typename Type::value_type>
{
- typedef is_interval_map_derivative<Type, typename Type::value_type> type;
- static const bool value = is_interval_container<Type>::value;
+ typedef is_interval_map_derivative<Type, typename Type::value_type> type;
+ static const bool value = is_interval_container<Type>::value;
};
template<class Type, class AssociateT>
struct is_interval_map_derivative
{
- typedef is_interval_map_derivative<Type, AssociateT> type;
- static const bool value = false;
+ typedef is_interval_map_derivative<Type, AssociateT> type;
+ static const bool value = false;
};
//------------------------------------------------------------------------------
@@ -106,21 +106,21 @@
template<class Type, class AssociateT>
struct is_intra_derivative
{
- typedef is_intra_derivative<Type, AssociateT> type;
- static const bool value =
- ( is_interval_set<Type>::value
- && is_interval_set_derivative<Type, AssociateT>::value)
- || ( is_interval_map<Type>::value
- && is_interval_map_derivative<Type, AssociateT>::value);
+ typedef is_intra_derivative<Type, AssociateT> type;
+ static const bool value =
+ ( is_interval_set<Type>::value
+ && is_interval_set_derivative<Type, AssociateT>::value)
+ || ( is_interval_map<Type>::value
+ && is_interval_map_derivative<Type, AssociateT>::value);
};
template<class Type, class AssociateT>
struct is_cross_derivative
{
- typedef is_cross_derivative<Type, AssociateT> type;
- static const bool value =
- ( is_interval_map<Type>::value
- && is_interval_set_derivative<Type, AssociateT>::value);
+ typedef is_cross_derivative<Type, AssociateT> type;
+ static const bool value =
+ ( is_interval_map<Type>::value
+ && is_interval_set_derivative<Type, AssociateT>::value);
};
@@ -129,24 +129,24 @@
//------------------------------------------------------------------------------
template<class Type> struct unknown_fineness
{
- typedef unknown_fineness<Type> type;
- static const int value = 0;
+ typedef unknown_fineness<Type> type;
+ static const int value = 0;
};
template<class Type> struct known_fineness
{
- typedef known_fineness<Type> type;
- static const int value = Type::fineness;
+ typedef known_fineness<Type> type;
+ static const int value = Type::fineness;
};
template<class Type>struct segmentational_fineness
{
- typedef segmentational_fineness<Type> type;
- static const int value =
- mpl::if_<is_interval_container<Type>,
- known_fineness<Type>,
- unknown_fineness<Type>
- >::type::value;
+ typedef segmentational_fineness<Type> type;
+ static const int value =
+ mpl::if_<is_interval_container<Type>,
+ known_fineness<Type>,
+ unknown_fineness<Type>
+ >::type::value;
};
@@ -158,44 +158,44 @@
template
<
- class Dom, ITL_COMPARE Cmp, template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
+ class Dom, ITL_COMPARE Cmp, template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet1,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet2
>
struct is_interval_set_companion<IntervalSet1<Dom,Cmp,Itv,Alc>,
- IntervalSet2<Dom,Cmp,Itv,Alc> >
+ IntervalSet2<Dom,Cmp,Itv,Alc> >
{
- typedef IntervalSet1<Dom,Cmp,Itv,Alc> GuideT;
- typedef IntervalSet2<Dom,Cmp,Itv,Alc> CompanionT;
- typedef is_interval_set_companion<GuideT,CompanionT> type;
+ typedef IntervalSet1<Dom,Cmp,Itv,Alc> GuideT;
+ typedef IntervalSet2<Dom,Cmp,Itv,Alc> CompanionT;
+ typedef is_interval_set_companion<GuideT,CompanionT> type;
- static const bool value = true;
+ static const bool value = true;
};
// Every IntervalSet can be a companion of every IntervalMap for
// operations intersection and erase.
template
<
- class Dom, class Cod, class Trt, ITL_COMPARE Cmp, ITL_COMBINE Cmb, ITL_SECTION Sec,
- template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
+ class Dom, class Cod, class Trt, ITL_COMPARE Cmp, ITL_COMBINE Cmb, ITL_SECTION Sec,
+ template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION,
- template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap,
+ template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap,
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
struct is_interval_set_companion<IntervalMap<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc>,
- IntervalSet<Dom, Cmp, Itv,Alc> >
+ IntervalSet<Dom, Cmp, Itv,Alc> >
{
- typedef IntervalMap<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> GuideT;
- typedef IntervalSet<Dom, Cmp, Itv,Alc> CompanionT;
- typedef is_interval_set_companion<GuideT,CompanionT> type;
+ typedef IntervalMap<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> GuideT;
+ typedef IntervalSet<Dom, Cmp, Itv,Alc> CompanionT;
+ typedef is_interval_set_companion<GuideT,CompanionT> type;
- static const bool value = true;
+ static const bool value = true;
};
template<class GuideT, class CompanionT> struct is_interval_set_companion
{
- typedef is_interval_set_companion<GuideT,CompanionT> type;
- enum{ value = is_interval_set_derivative<GuideT,CompanionT>::value };
+ typedef is_interval_set_companion<GuideT,CompanionT> type;
+ enum{ value = is_interval_set_derivative<GuideT,CompanionT>::value };
};
@@ -206,27 +206,27 @@
template
<
- class Dom, class Cod, class Trt, ITL_COMPARE Cmp, ITL_COMBINE Cmb, ITL_SECTION Sec,
- template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
+ class Dom, class Cod, class Trt, ITL_COMPARE Cmp, ITL_COMBINE Cmb, ITL_SECTION Sec,
+ template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION,
- template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap1,
+ template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap1,
template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION,
- template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap2
+ template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap2
>
struct is_interval_map_companion<IntervalMap1<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc>,
- IntervalMap2<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> >
+ IntervalMap2<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> >
{
- typedef IntervalMap1<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> GuideT;
- typedef IntervalMap2<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> CompanionT;
- typedef is_interval_map_companion<GuideT,CompanionT> type;
+ typedef IntervalMap1<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> GuideT;
+ typedef IntervalMap2<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> CompanionT;
+ typedef is_interval_map_companion<GuideT,CompanionT> type;
- static const bool value = true;
+ static const bool value = true;
};
template<class GuideT, class CompanionT> struct is_interval_map_companion
{
- typedef is_interval_map_companion<GuideT,CompanionT> type;
- enum{ value = is_interval_map_derivative<GuideT,CompanionT>::value };
+ typedef is_interval_map_companion<GuideT,CompanionT> type;
+ enum{ value = is_interval_map_derivative<GuideT,CompanionT>::value };
};
@@ -238,21 +238,21 @@
template<class GuideT, class CompanionT>
struct is_coarser_interval_set_companion
{
- typedef is_coarser_interval_set_companion<GuideT, CompanionT> type;
- static const bool value =
- is_interval_set_companion<GuideT, CompanionT>::value
- && ( segmentational_fineness<GuideT>::value
- > segmentational_fineness<CompanionT>::value);
+ typedef is_coarser_interval_set_companion<GuideT, CompanionT> type;
+ static const bool value =
+ is_interval_set_companion<GuideT, CompanionT>::value
+ && ( segmentational_fineness<GuideT>::value
+ > segmentational_fineness<CompanionT>::value);
};
template<class GuideT, class CompanionT>
struct is_coarser_interval_map_companion
{
- typedef is_coarser_interval_map_companion<GuideT, CompanionT> type;
- static const bool value =
- is_interval_map_companion<GuideT, CompanionT>::value
- && ( segmentational_fineness<GuideT>::value
- > segmentational_fineness<CompanionT>::value);
+ typedef is_coarser_interval_map_companion<GuideT, CompanionT> type;
+ static const bool value =
+ is_interval_map_companion<GuideT, CompanionT>::value
+ && ( segmentational_fineness<GuideT>::value
+ > segmentational_fineness<CompanionT>::value);
};
@@ -263,57 +263,57 @@
template<class GuideT, class CompanionT>
struct is_right_interval_set_combinable
{
- typedef is_right_interval_set_combinable<GuideT,CompanionT> type;
- enum{ value = mpl::and_< is_interval_set<GuideT>
- , is_interval_set_companion<GuideT, CompanionT>
- >::value
- };
+ typedef is_right_interval_set_combinable<GuideT,CompanionT> type;
+ enum{ value = mpl::and_< is_interval_set<GuideT>
+ , is_interval_set_companion<GuideT, CompanionT>
+ >::value
+ };
};
template<class GuideT, class CompanionT>
struct is_right_interval_map_combinable
{
- typedef is_right_interval_map_combinable<GuideT,CompanionT> type;
- enum{ value = mpl::and_< is_interval_map<GuideT>
- , is_interval_map_companion<GuideT, CompanionT>
- >::value
- };
+ typedef is_right_interval_map_combinable<GuideT,CompanionT> type;
+ enum{ value = mpl::and_< is_interval_map<GuideT>
+ , is_interval_map_companion<GuideT, CompanionT>
+ >::value
+ };
};
template<class GuideT, class CompanionT>
struct is_right_intra_combinable
{
- typedef is_right_intra_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_<is_right_interval_set_combinable<GuideT, CompanionT>,
- is_right_interval_map_combinable<GuideT, CompanionT>
- >::value;
+ typedef is_right_intra_combinable<GuideT,CompanionT> type;
+ static const bool value =
+ mpl::or_<is_right_interval_set_combinable<GuideT, CompanionT>,
+ is_right_interval_map_combinable<GuideT, CompanionT>
+ >::value;
};
template<class GuideT, class CompanionT>
struct is_right_cross_combinable
{
- typedef is_right_cross_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::and_
- < is_interval_map<GuideT>
- , mpl::or_< is_interval_map_companion<GuideT, CompanionT>
- , is_interval_set_companion<GuideT, CompanionT> >
- >::value;
+ typedef is_right_cross_combinable<GuideT,CompanionT> type;
+ static const bool value =
+ mpl::and_
+ < is_interval_map<GuideT>
+ , mpl::or_< is_interval_map_companion<GuideT, CompanionT>
+ , is_interval_set_companion<GuideT, CompanionT> >
+ >::value;
};
template<class GuideT, class CompanionT>
struct is_right_inter_combinable
{
- typedef is_right_inter_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_
- <
- mpl::and_<is_interval_map<GuideT>,
- is_right_cross_combinable<GuideT, CompanionT> >
+ typedef is_right_inter_combinable<GuideT,CompanionT> type;
+ static const bool value =
+ mpl::or_
+ <
+ mpl::and_<is_interval_map<GuideT>,
+ is_right_cross_combinable<GuideT, CompanionT> >
, mpl::and_<is_interval_set<GuideT>,
- is_right_intra_combinable<GuideT, CompanionT> >
- >::value;
+ is_right_intra_combinable<GuideT, CompanionT> >
+ >::value;
};
//------------------------------------------------------------------------------
@@ -322,57 +322,57 @@
template<class GuideT, class CompanionT>
struct is_binary_interval_set_combinable
{
- typedef is_binary_interval_set_combinable<GuideT,CompanionT> type;
- enum{ value = mpl::and_< is_interval_set<GuideT>
- , is_coarser_interval_set_companion<GuideT, CompanionT>
- >::value
- };
+ typedef is_binary_interval_set_combinable<GuideT,CompanionT> type;
+ enum{ value = mpl::and_< is_interval_set<GuideT>
+ , is_coarser_interval_set_companion<GuideT, CompanionT>
+ >::value
+ };
};
template<class GuideT, class CompanionT>
struct is_binary_interval_map_combinable
{
- typedef is_binary_interval_map_combinable<GuideT,CompanionT> type;
- enum{ value = mpl::and_< is_interval_map<GuideT>
- , is_coarser_interval_map_companion<GuideT, CompanionT>
- >::value
- };
+ typedef is_binary_interval_map_combinable<GuideT,CompanionT> type;
+ enum{ value = mpl::and_< is_interval_map<GuideT>
+ , is_coarser_interval_map_companion<GuideT, CompanionT>
+ >::value
+ };
};
template<class GuideT, class CompanionT>
struct is_binary_intra_combinable
{
- typedef is_binary_intra_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_<is_binary_interval_set_combinable<GuideT, CompanionT>,
- is_binary_interval_map_combinable<GuideT, CompanionT>
- >::value;
+ typedef is_binary_intra_combinable<GuideT,CompanionT> type;
+ static const bool value =
+ mpl::or_<is_binary_interval_set_combinable<GuideT, CompanionT>,
+ is_binary_interval_map_combinable<GuideT, CompanionT>
+ >::value;
};
template<class GuideT, class CompanionT>
struct is_binary_cross_combinable
{
- typedef is_binary_cross_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::and_
- < is_interval_map<GuideT>
- , mpl::or_< is_coarser_interval_map_companion<GuideT, CompanionT>
- , is_interval_set_companion<GuideT, CompanionT> >
- >::value;
+ typedef is_binary_cross_combinable<GuideT,CompanionT> type;
+ static const bool value =
+ mpl::and_
+ < is_interval_map<GuideT>
+ , mpl::or_< is_coarser_interval_map_companion<GuideT, CompanionT>
+ , is_interval_set_companion<GuideT, CompanionT> >
+ >::value;
};
template<class GuideT, class CompanionT>
struct is_binary_inter_combinable
{
- typedef is_binary_inter_combinable<GuideT,CompanionT> type;
- static const bool value =
- mpl::or_
- <
- mpl::and_<is_interval_map<GuideT>,
- is_binary_cross_combinable<GuideT, CompanionT> >
+ typedef is_binary_inter_combinable<GuideT,CompanionT> type;
+ static const bool value =
+ mpl::or_
+ <
+ mpl::and_<is_interval_map<GuideT>,
+ is_binary_cross_combinable<GuideT, CompanionT> >
, mpl::and_<is_interval_set<GuideT>,
- is_binary_intra_combinable<GuideT, CompanionT> >
- >::value;
+ is_binary_intra_combinable<GuideT, CompanionT> >
+ >::value;
};
Modified: sandbox/itl/boost/itl/type_traits/is_continuous.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_continuous.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_continuous.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_continuous_JOFA_080910_H__
#define __itl_type_traits_is_continuous_JOFA_080910_H__
@@ -15,36 +15,36 @@
template <class Type> struct is_continuous;
template<> struct is_continuous<float>
- {
- typedef is_continuous<float> type;
- static const bool value = true;
- };
+ {
+ typedef is_continuous<float> type;
+ static const bool value = true;
+ };
template<> struct is_continuous<double>
- {
- typedef is_continuous<double> type;
- static const bool value = true;
- };
+ {
+ typedef is_continuous<double> type;
+ static const bool value = true;
+ };
template<> struct is_continuous<std::string>
- {
- typedef is_continuous<std::string> type;
- static const bool value = true;
- };
+ {
+ typedef is_continuous<std::string> type;
+ static const bool value = true;
+ };
#ifdef ITL_NEEDS_RATIONAL_IS_CONTINUOUS
#define ITL_HAS_RATIONAL_IS_CONTINUOUS
template<class Integral>
struct is_continuous<boost::rational<Integral> >
- {
- typedef is_continuous<boost::rational<Integral> > type;
- static const bool value = true;
- };
+ {
+ typedef is_continuous<boost::rational<Integral> > type;
+ static const bool value = true;
+ };
#endif
template <class Type> struct is_continuous
- {
- typedef is_continuous<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_continuous<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_interval_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_container.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,20 +1,20 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_interval_container_JOFA_081004_H__
#define __itl_type_traits_is_interval_container_JOFA_081004_H__
namespace boost{ namespace itl
{
template <class Type> struct is_interval_container
- {
- typedef is_interval_container<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_interval_container<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,20 +1,20 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_interval_separator_JOFA_081004_H__
#define __itl_type_traits_is_interval_separator_JOFA_081004_H__
namespace boost{ namespace itl
{
template <class Type> struct is_interval_separator
- {
- typedef is_interval_separator<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_interval_separator<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,20 +1,20 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_interval_splitter_JOFA_081004_H__
#define __itl_type_traits_is_interval_splitter_JOFA_081004_H__
namespace boost{ namespace itl
{
template <class Type> struct is_interval_splitter
- {
- typedef is_interval_splitter<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_interval_splitter<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_map.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,20 +1,20 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_map_JOFA_081107_H__
#define __itl_type_traits_is_map_JOFA_081107_H__
namespace boost{ namespace itl
{
template <class Type> struct is_map
- {
- typedef is_map<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_map<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_set.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,20 +1,20 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_set_JOFA_081004_H__
#define __itl_type_traits_is_set_JOFA_081004_H__
namespace boost{ namespace itl
{
template <class Type> struct is_set
- {
- typedef is_set<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_set<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_total.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_total.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_total.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,20 +1,20 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_is_total_JOFA_081004_H__
#define __itl_type_traits_is_total_JOFA_081004_H__
namespace boost{ namespace itl
{
template <class Type> struct is_total
- {
- typedef is_total<Type> type;
- static const bool value = false;
- };
+ {
+ typedef is_total<Type> type;
+ static const bool value = false;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/neutron.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/neutron.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/neutron.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_neutron_JOFA_080912_H__
#define __itl_type_traits_neutron_JOFA_080912_H__
Modified: sandbox/itl/boost/itl/type_traits/size.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/size.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/size.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_size_JOFA_080911_H__
#define __itl_type_traits_size_JOFA_080911_H__
Modified: sandbox/itl/boost/itl/type_traits/succ_pred.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/succ_pred.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/succ_pred.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_type_traits_succ_pred_JOFA_080913_H__
#define __itl_type_traits_succ_pred_JOFA_080913_H__
Modified: sandbox/itl/boost/itl/type_traits/value_size.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/value_size.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/value_size.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
/*-----------------------------------------------------------------------------+
Copyright (c) 2008-2009: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
Modified: sandbox/itl/boost/itl_xt/enum_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/enum_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/enum_bitset.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_enum_bitset_JOFA_021204_H__
#define __itl_enum_bitset_JOFA_021204_H__
Modified: sandbox/itl/boost/itl_xt/episode_product.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/episode_product.hpp (original)
+++ sandbox/itl/boost/itl_xt/episode_product.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_episode_product_hpp_JOFA_011005_H__
#define __itl_episode_product_hpp_JOFA_011005_H__
Modified: sandbox/itl/boost/itl_xt/episode_set.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/episode_set.hpp (original)
+++ sandbox/itl/boost/itl_xt/episode_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_episode_set_hpp_JOFA_011015_H__
#define __itl_episode_set_hpp_JOFA_011015_H__
@@ -69,15 +69,15 @@
template <class TimeT, class TypeDomain>
class episode_set : public itl::set<typed_episode<TimeT, TypeDomain>*,
#ifdef ITL_USE_COMPARE_TEMPLATE_TEMPLATE
- Less_TypedEpisodeATP
+ Less_TypedEpisodeATP
#else
- Less_TypedEpisodeATP<typed_episode<TimeT, TypeDomain>*>
+ Less_TypedEpisodeATP<typed_episode<TimeT, TypeDomain>*>
#endif
>
{
// all elements must have the same type from TypeDomain
public:
- typedef typed_episode<TimeT, TypeDomain>* episode_type;
+ typedef typed_episode<TimeT, TypeDomain>* episode_type;
typedef itl::set<typed_episode<TimeT, TypeDomain>*,
ITL_COMPARE_INSTANCE(Less_TypedEpisodeATP,episode_type)> base_type;
typedef typename base_type::iterator iterator;
Modified: sandbox/itl/boost/itl_xt/fixtupelconst.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/fixtupelconst.hpp (original)
+++ sandbox/itl/boost/itl_xt/fixtupelconst.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_FixTupelConstT_JOFA_040621_H__
#define __itl_FixTupelConstT_JOFA_040621_H__
Modified: sandbox/itl/boost/itl_xt/gentorit.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/gentorit.hpp (original)
+++ sandbox/itl/boost/itl_xt/gentorit.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class GentorT
--------------------------------------------------------------------*/
Modified: sandbox/itl/boost/itl_xt/group_order.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/group_order.hpp (original)
+++ sandbox/itl/boost/itl_xt/group_order.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __group_order_JOFA_040621_H__
#define __group_order_JOFA_040621_H__
Modified: sandbox/itl/boost/itl_xt/grouping.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/grouping.hpp (original)
+++ sandbox/itl/boost/itl_xt/grouping.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __grouping_JOFA_040621_H__
#define __grouping_JOFA_040621_H__
Modified: sandbox/itl/boost/itl_xt/itvgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/itvgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/itvgentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class ItvGentorT
--------------------------------------------------------------------*/
@@ -65,7 +65,7 @@
{
NumberGentorT<unsigned> NATGentor;
ItvDomTV x1 = m_ItvDomTVGentor(m_valueRange);
- itl::bound_type bndTypes = NATGentor(4);
+ itl::bound_type bndTypes = NATGentor(4);
unsigned upOrDown = NATGentor(1);
unsigned decideEmpty = NATGentor(2);
Modified: sandbox/itl/boost/itl_xt/list.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/list.hpp (original)
+++ sandbox/itl/boost/itl_xt/list.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class itl::list
a general list class that extends stl-lists
Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
Modified: sandbox/itl/boost/itl_xt/numbergentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/numbergentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/numbergentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class NumberGentorT
A random generator for numbers
@@ -100,7 +100,7 @@
}
void setRange(interval<NumTV> rng) { m_valueRange = rng; }
- void setRange(NumTV lwb, NumTV upb) { m_valueRange = interval<NumTV>::rightopen(lwb,upb); }
+ void setRange(NumTV lwb, NumTV upb) { m_valueRange = interval<NumTV>::rightopen(lwb,upb); }
void calibrate(const RandomGentorProfile<NumTV>& profile)
{
Modified: sandbox/itl/boost/itl_xt/ordered_type.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/ordered_type.hpp (original)
+++ sandbox/itl/boost/itl_xt/ordered_type.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __ordered_type_h_JOFA_011005_H__
#define __ordered_type_h_JOFA_011005_H__
Modified: sandbox/itl/boost/itl_xt/prefix_set.cpp
==============================================================================
--- sandbox/itl/boost/itl_xt/prefix_set.cpp (original)
+++ sandbox/itl/boost/itl_xt/prefix_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <stdafx.h>
#include "prefix_set.h"
Modified: sandbox/itl/boost/itl_xt/prefix_set.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/prefix_set.hpp (original)
+++ sandbox/itl/boost/itl_xt/prefix_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_prefix_set_JOFA_040902_H__
#define __itl_prefix_set_JOFA_040902_H__
Modified: sandbox/itl/boost/itl_xt/product_history.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/product_history.hpp (original)
+++ sandbox/itl/boost/itl_xt/product_history.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __product_history_h_JOFA_011005_H__
#define __product_history_h_JOFA_011005_H__
Modified: sandbox/itl/boost/itl_xt/random.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/random.hpp (original)
+++ sandbox/itl/boost/itl_xt/random.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __RANDOM_H_JOFA_990223__
#define __RANDOM_H_JOFA_990223__
Modified: sandbox/itl/boost/itl_xt/randomnumber.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/randomnumber.hpp (original)
+++ sandbox/itl/boost/itl_xt/randomnumber.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __RANDOMNUMBER_H_JOFA_990223__
#define __RANDOMNUMBER_H_JOFA_990223__
Modified: sandbox/itl/boost/itl_xt/seqgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/seqgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/seqgentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class SeqGentorT
A random generator for Sequences.
@@ -54,7 +54,7 @@
{ m_domainGentor = gentor; }
void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
+ { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
void setRangeOfSampleSize(const interval<int>& szRange)
{ BOOST_ASSERT(szRange.is_rightopen()); m_sampleSizeRange = szRange; }
Modified: sandbox/itl/boost/itl_xt/setgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/setgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/setgentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class SetGentorT
A random generator for Sets.
Modified: sandbox/itl/boost/itl_xt/statvardesct.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/statvardesct.hpp (original)
+++ sandbox/itl/boost/itl_xt/statvardesct.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __StatVarDescT_JOFA_040614_H__
#define __StatVarDescT_JOFA_040614_H__
Modified: sandbox/itl/boost/itl_xt/string_list.cpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_list.cpp (original)
+++ sandbox/itl/boost/itl_xt/string_list.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------
A general list of strings
---------------------------------------------------------------------------------*/
Modified: sandbox/itl/boost/itl_xt/string_list.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_list.hpp (original)
+++ sandbox/itl/boost/itl_xt/string_list.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class itl::string_list
A List of Strings.
Modified: sandbox/itl/boost/itl_xt/string_map.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_map.hpp (original)
+++ sandbox/itl/boost/itl_xt/string_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_string_map_JOFA_021215_H__
#define __itl_string_map_JOFA_021215_H__
Modified: sandbox/itl/boost/itl_xt/string_set.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_set.hpp (original)
+++ sandbox/itl/boost/itl_xt/string_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------
set of strings
---------------------------------------------------------------------------------*/
Modified: sandbox/itl/boost/itl_xt/string_sheet.cpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_sheet.cpp (original)
+++ sandbox/itl/boost/itl_xt/string_sheet.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <stdafx.h>
#include "string_sheet.h"
#include <boost/itl/type_traits/to_string.hpp>
Modified: sandbox/itl/boost/itl_xt/string_sheet.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/string_sheet.hpp (original)
+++ sandbox/itl/boost/itl_xt/string_sheet.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_string_sheet_JOFA_050209_H__
#define __itl_string_sheet_JOFA_050209_H__
Modified: sandbox/itl/boost/itl_xt/stringpattern_set.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/stringpattern_set.hpp (original)
+++ sandbox/itl/boost/itl_xt/stringpattern_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_stringpattern_set_JOFA_040902_H__
#define __itl_stringpattern_set_JOFA_040902_H__
Modified: sandbox/itl/boost/itl_xt/tuple_computer.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/tuple_computer.hpp (original)
+++ sandbox/itl/boost/itl_xt/tuple_computer.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __tuple_computer_JOFA_040614_H__
#define __tuple_computer_JOFA_040614_H__
Modified: sandbox/itl/boost/itl_xt/typed_episode.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/typed_episode.hpp (original)
+++ sandbox/itl/boost/itl_xt/typed_episode.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_typed_episode_hpp_JOFA_011015_H__
#define __itl_typed_episode_hpp_JOFA_011015_H__
Modified: sandbox/itl/boost/itl_xt/var_permutation.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_permutation.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_permutation.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __var_permutation_JOFA_040621_H__
#define __var_permutation_JOFA_040621_H__
Modified: sandbox/itl/boost/itl_xt/var_tuple.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_tuple.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_tuple.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __var_tuple_JOFA_040614_H__
#define __var_tuple_JOFA_040614_H__
Modified: sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __var_tuple_inscriptor_JOFA_041006_H__
#define __var_tuple_inscriptor_JOFA_041006_H__
Modified: sandbox/itl/boost/itl_xt/var_tuple_order.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/var_tuple_order.hpp (original)
+++ sandbox/itl/boost/itl_xt/var_tuple_order.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,8 +1,8 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -26,7 +26,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __var_tuple_order_JOFA_040620_H__
#define __var_tuple_order_JOFA_040620_H__
Modified: sandbox/itl/boost/validate/driver/collector_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/collector_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/collector_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -19,7 +19,7 @@
namespace boost{namespace itl
{
- class collector_driver : public itl_driver
+ class collector_driver : public itl_driver
{
public:
collector_driver() { setProfile(); }
Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -104,9 +104,9 @@
std::cout << "------------------------------------------------------------------------------" << std::endl;
}
- void reportFrequencies(const std::string& filename)
+ void reportFrequencies(const std::string& filename)
{
- FILE* fp = fopen(filename.c_str(), "w");
+ FILE* fp = fopen(filename.c_str(), "w");
int valid_count = 1;
FORALL(ValidationCounterT, it, _frequencies)
{
@@ -123,7 +123,7 @@
<< chooser.asString();
}
- protected:
+ protected:
void setValid(bool truth) { _isValid = truth; }
void setRootTypeNames()
Modified: sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -108,26 +108,26 @@
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(domainChoice) {
- case DomainType::Int:
- switch(neutronizerChoice) {
- NEURONIZER_CASES(interval_morphic_validater, split_interval_map, int, int)
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
+ case DomainType::Int:
+ switch(neutronizerChoice) {
+ NEURONIZER_CASES(interval_morphic_validater, split_interval_map, int, int)
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
neutronizerChoice, _neutronizerChoice);
- }
+ }
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
domainChoice, _domainChoice);
}
}
case RootType::interval_map: {
switch(domainChoice) {
- case DomainType::Int:
- switch(neutronizerChoice) {
- NEURONIZER_CASES(interval_morphic_validater, interval_map, int, int)
+ case DomainType::Int:
+ switch(neutronizerChoice) {
+ NEURONIZER_CASES(interval_morphic_validater, interval_map, int, int)
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
domainChoice, _domainChoice);
}
}
- }
+ }
default: return choiceError(ITL_LOCATION("rootChoice:\n"), rootChoice, _rootChoice);
} //switch(rootChoice)
Modified: sandbox/itl/boost/validate/driver/itl_order_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_order_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_order_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -18,7 +18,7 @@
namespace boost{namespace itl
{
- class itl_order_driver : public itl_driver
+ class itl_order_driver : public itl_driver
{
public:
itl_order_driver() { setProfile(); }
Modified: sandbox/itl/boost/validate/driver/itl_set_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_set_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_set_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -18,7 +18,7 @@
namespace boost{namespace itl
{
- class itl_set_driver : public itl_driver
+ class itl_set_driver : public itl_driver
{
public:
itl_set_driver() { setProfile(); }
Modified: sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -20,8 +20,8 @@
namespace boost{namespace itl
{
- template<class Law>
- class itl_single_law_driver : public itl_driver
+ template<class Law>
+ class itl_single_law_driver : public itl_driver
{
public:
itl_single_law_driver() { setProfile(); }
@@ -125,38 +125,38 @@
}
case RootType::split_interval_map: {
switch(domainChoice) {
- case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
- return new itl_induced_relations_validater<split_interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
- return new itl_induced_relations_validater<split_interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
- return new itl_induced_relations_validater<split_interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
- return new itl_induced_relations_validater<split_interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
+ case DomainType::Int:
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new itl_induced_relations_validater<split_interval_map<int,int,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher:
+ return new itl_induced_relations_validater<split_interval_map<int,int,partial_enricher> >;
+ case NeutronHandlerType::total_absorber:
+ return new itl_induced_relations_validater<split_interval_map<int,int,total_absorber> >;
+ case NeutronHandlerType::total_enricher:
+ return new itl_induced_relations_validater<split_interval_map<int,int,total_enricher> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
neutronizerChoice, _neutronizerChoice);
- }
+ }
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
domainChoice, _domainChoice);
}
}
case RootType::interval_map: {
switch(domainChoice) {
- case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
- return new itl_induced_relations_validater<interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
- return new itl_induced_relations_validater<interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
- return new itl_induced_relations_validater<interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
- return new itl_induced_relations_validater<interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
+ case DomainType::Int:
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new itl_induced_relations_validater<interval_map<int,int,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher:
+ return new itl_induced_relations_validater<interval_map<int,int,partial_enricher> >;
+ case NeutronHandlerType::total_absorber:
+ return new itl_induced_relations_validater<interval_map<int,int,total_absorber> >;
+ case NeutronHandlerType::total_enricher:
+ return new itl_induced_relations_validater<interval_map<int,int,total_enricher> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
neutronizerChoice, _neutronizerChoice);
- }
+ }
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
domainChoice, _domainChoice);
}
Modified: sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -18,7 +18,7 @@
namespace boost{namespace itl
{
- class signed_quantifier_driver : public itl_driver
+ class signed_quantifier_driver : public itl_driver
{
public:
signed_quantifier_driver() { setProfile(); }
Modified: sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -18,7 +18,7 @@
namespace boost{namespace itl
{
- class unsigned_quantifier_driver : public itl_driver
+ class unsigned_quantifier_driver : public itl_driver
{
public:
unsigned_quantifier_driver() { setProfile(); }
Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/validate/type/nat.hpp>
Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
Modified: sandbox/itl/boost/validate/gentor/rangegentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/rangegentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/rangegentor.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class IntevalGentor
A random generator for Sets.
Modified: sandbox/itl/boost/validate/itl_relations_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl_relations_validater.hpp (original)
+++ sandbox/itl/boost/validate/itl_relations_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -19,7 +19,7 @@
namespace boost{namespace itl
{
- class ItlRelationsValidater : public itl_driver
+ class ItlRelationsValidater : public itl_driver
{
public:
ItlRelationsValidater() { setProfile(); }
@@ -123,38 +123,38 @@
}
case RootType::split_interval_map: {
switch(domainChoice) {
- case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
- return new itl_induced_relations_validater<split_interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
- return new itl_induced_relations_validater<split_interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
- return new itl_induced_relations_validater<split_interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
- return new itl_induced_relations_validater<split_interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
+ case DomainType::Int:
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new itl_induced_relations_validater<split_interval_map<int,int,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher:
+ return new itl_induced_relations_validater<split_interval_map<int,int,partial_enricher> >;
+ case NeutronHandlerType::total_absorber:
+ return new itl_induced_relations_validater<split_interval_map<int,int,total_absorber> >;
+ case NeutronHandlerType::total_enricher:
+ return new itl_induced_relations_validater<split_interval_map<int,int,total_enricher> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
neutronizerChoice, _neutronizerChoice);
- }
+ }
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
domainChoice, _domainChoice);
}
}
case RootType::interval_map: {
switch(domainChoice) {
- case DomainType::Int:
- switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber:
- return new itl_induced_relations_validater<interval_map<int,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher:
- return new itl_induced_relations_validater<interval_map<int,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber:
- return new itl_induced_relations_validater<interval_map<int,int,total_absorber> >;
- case NeutronHandlerType::total_enricher:
- return new itl_induced_relations_validater<interval_map<int,int,total_enricher> >;
- default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
+ case DomainType::Int:
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new itl_induced_relations_validater<interval_map<int,int,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher:
+ return new itl_induced_relations_validater<interval_map<int,int,partial_enricher> >;
+ case NeutronHandlerType::total_absorber:
+ return new itl_induced_relations_validater<interval_map<int,int,total_absorber> >;
+ case NeutronHandlerType::total_enricher:
+ return new itl_induced_relations_validater<interval_map<int,int,total_enricher> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"),
neutronizerChoice, _neutronizerChoice);
- }
+ }
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: domainChoice:\n"),
domainChoice, _domainChoice);
}
Modified: sandbox/itl/boost/validate/laws/element_order.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/element_order.hpp (original)
+++ sandbox/itl/boost/validate/laws/element_order.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_element_order_hpp_JOFA_090202__
#define __itl_element_order_hpp_JOFA_090202__
@@ -42,36 +42,36 @@
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_element_equal(a, b);
- bool rhs = (a_atomic == b_atomic);
+ bool lhs = is_element_equal(a, b);
+ bool rhs = (a_atomic == b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
bool debug_holds()
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_element_equal(a, b);
- bool rhs = (a_atomic == b_atomic);
+ bool lhs = is_element_equal(a, b);
+ bool rhs = (a_atomic == b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
size_t size()const
@@ -106,36 +106,36 @@
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_element_less(a, b);
- bool rhs = a_atomic < b_atomic;
+ bool lhs = is_element_less(a, b);
+ bool rhs = a_atomic < b_atomic;
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
bool debug_holds()
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_element_less(a, b);
- bool rhs = a_atomic < b_atomic;
+ bool lhs = is_element_less(a, b);
+ bool rhs = a_atomic < b_atomic;
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
@@ -172,36 +172,36 @@
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_element_greater(a, b);
- bool rhs = a_atomic > b_atomic;
+ bool lhs = is_element_greater(a, b);
+ bool rhs = a_atomic > b_atomic;
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
bool debug_holds()
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_element_greater(a, b);
- bool rhs = a_atomic > b_atomic;
+ bool lhs = is_element_greater(a, b);
+ bool rhs = a_atomic > b_atomic;
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
Modified: sandbox/itl/boost/validate/laws/induced_relation.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/induced_relation.hpp (original)
+++ sandbox/itl/boost/validate/laws/induced_relation.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_induced_relation_hpp_JOFA_090204__
#define __itl_induced_relation_hpp_JOFA_090204__
@@ -16,12 +16,12 @@
namespace boost{namespace itl
{
// An InducedRelation can be represented as a triangular commuting diagram
- // where f is a unary function and R a binary predicate or relation
+ // where f is a unary function and R a binary predicate or relation
// ---------------------------------------------------------------------------
// (a,b)--f-->(a',b')
- // \ /
- // R \ == / R
- // \ /
+ // \ /
+ // R \ == / R
+ // \ /
// V V
// {true,false}
// ---------------------------------------------------------------------------
@@ -58,12 +58,12 @@
// lhs := a rel b
SourceT a = this->template getInputValue<operand_a>();
SourceT b = this->template getInputValue<operand_b>();
- bool lhs = RelationT<SourceT>()(a,b);
+ bool lhs = RelationT<SourceT>()(a,b);
// --- right hand side -----------------------
- TargetT f_a, f_b;
- FunctionT<TargetT,SourceT>()(f_a, a);
- FunctionT<TargetT,SourceT>()(f_b, b);
- bool rhs = RelationT<TargetT>()(f_a, f_b);
+ TargetT f_a, f_b;
+ FunctionT<TargetT,SourceT>()(f_a, a);
+ FunctionT<TargetT,SourceT>()(f_b, b);
+ bool rhs = RelationT<TargetT>()(f_a, f_b);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -80,7 +80,7 @@
bool debug_holds()
{
- return holds();
+ return holds();
}
}; //class InducedRelation
Modified: sandbox/itl/boost/validate/laws/inversion_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/inversion_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/inversion_laws.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_inversion_laws_h_JOFA_071124__
#define __itl_inversion_laws_h_JOFA_071124__
@@ -19,7 +19,7 @@
template <typename Type,
template<class>class Combiner = inplace_plus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = itl::std_equal>
class InplaceNaturalInversion
: public Law<InplaceNaturalInversion<Type,Combiner,Equality>,
LOKI_TYPELIST_1(Type), LOKI_TYPELIST_2(Type,Type)>
@@ -30,7 +30,7 @@
//Output = (lhs_result, rhs_result)
public:
- typedef typename inverse<Combiner<Type> >::type InverseCombinerT;
+ typedef typename inverse<Combiner<Type> >::type InverseCombinerT;
std::string name()const { return "InplaceNaturalInversion"; }
std::string formula()const { return "a -= a; a == 0"; }
@@ -40,7 +40,7 @@
return "NaturalInversion<"+type_to_string<Type>::apply()+","
+unary_template_to_string<Combiner>::apply()+","
+unary_template_to_string<Equality>::apply()
- +">";
+ +">";
}
public:
@@ -59,9 +59,9 @@
}
bool debug_holds()
- {
- return holds();
- }
+ {
+ return holds();
+ }
size_t size()const { return value_size<Type>::apply(this->template getInputValue<operand_a>()); }
};
@@ -69,7 +69,7 @@
template <typename Type,
template<class>class Combiner = inplace_plus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = itl::std_equal>
class InplaceInverseExistence
: public Law<InplaceInverseExistence<Type,Combiner,Equality>,
LOKI_TYPELIST_1(Type), LOKI_TYPELIST_2(Type,Type)>
@@ -80,7 +80,7 @@
//Output = (lhs_result, rhs_result)
public:
- typedef typename inverse<Combiner<Type> >::type InverseCombinerT;
+ typedef typename inverse<Combiner<Type> >::type InverseCombinerT;
std::string name()const { return "InplaceInverseExistence"; }
std::string formula()const { return "(0-a) + a == 0"; }
@@ -90,19 +90,19 @@
return "InverseExistence<"+type_to_string<Type>::apply()+","
+unary_template_to_string<Combiner>::apply()+","
+unary_template_to_string<Equality>::apply()
- +">";
+ +">";
}
public:
bool holds()
{
- Type lhs = Combiner<Type>::neutron();
- Type value_a = this->template getInputValue<operand_a>();
- // lhs = (0 - a)
+ Type lhs = Combiner<Type>::neutron();
+ Type value_a = this->template getInputValue<operand_a>();
+ // lhs = (0 - a)
InverseCombinerT()(lhs, value_a);
- // lhs = (0 - a) + a
- Combiner<Type>()(lhs, value_a);
+ // lhs = (0 - a) + a
+ Combiner<Type>()(lhs, value_a);
Type rhs = Combiner<Type>::neutron();
@@ -113,9 +113,9 @@
}
bool debug_holds()
- {
- return holds();
- }
+ {
+ return holds();
+ }
size_t size()const { return value_size<Type>::apply(this->template getInputValue<operand_a>()); }
};
Modified: sandbox/itl/boost/validate/laws/map_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/map_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/map_laws.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_map_laws_hpp_JOFA_071124__
#define __itl_map_laws_hpp_JOFA_071124__
@@ -99,10 +99,10 @@
// lhs := (a.absorb_neutrons() == b.absorb_neutrons())
MapT a = this->template getInputValue<operand_a>();
MapT a_protonic = a;
- a_protonic.absorb_neutrons();
+ a_protonic.absorb_neutrons();
MapT b = this->template getInputValue<operand_b>();
MapT b_protonic = b;
- b_protonic.absorb_neutrons();
+ b_protonic.absorb_neutrons();
bool lhs = a_protonic == b_protonic;
@@ -117,44 +117,44 @@
}
bool debug_holds()
- {
+ {
// (a.absorb_neutrons() == b.absorb_neutrons()) == is_protonic_equal(a, b)
// --- left hand side ------------------------
// lhs := (a.absorb_neutrons() == b.absorb_neutrons())
- cout << name() << "::debug_holds():" << endl;
- cout << "Instance: " << typeString() << endl;
- cout << "Formula: " << formula() << endl;
+ cout << name() << "::debug_holds():" << endl;
+ cout << "Instance: " << typeString() << endl;
+ cout << "Formula: " << formula() << endl;
MapT a = this->template getInputValue<operand_a>();
MapT b = this->template getInputValue<operand_b>();
- cout << "a: " << a.as_string() << endl;
- cout << "b: " << b.as_string() << endl;
+ cout << "a: " << a.as_string() << endl;
+ cout << "b: " << b.as_string() << endl;
MapT a_protonic = a;
- a_protonic.absorb_neutrons();
+ a_protonic.absorb_neutrons();
MapT b_protonic = b;
- b_protonic.absorb_neutrons();
+ b_protonic.absorb_neutrons();
- cout << "a.absorb_neutrons(): " << a_protonic.as_string() << endl;
- cout << "b.absorb_neutrons(): " << b_protonic.as_string() << endl;
+ cout << "a.absorb_neutrons(): " << a_protonic.as_string() << endl;
+ cout << "b.absorb_neutrons(): " << b_protonic.as_string() << endl;
bool lhs = a_protonic == b_protonic;
- cout << "lhs := (a.absorb_neutrons() == b.absorb_neutrons()): " << lhs << endl;
+ cout << "lhs := (a.absorb_neutrons() == b.absorb_neutrons()): " << lhs << endl;
// --- right hand side -----------------------
// rhs := is_protonic_equal(a, b)
bool rhs = is_protonic_equal(a, b);
- cout << "rhs := is_protonic_equal(a, b): " << rhs << endl;
+ cout << "rhs := is_protonic_equal(a, b): " << rhs << endl;
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
return lhs == rhs;
- }
+ }
size_t size()const
{
Modified: sandbox/itl/boost/validate/laws/monoid.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/monoid.hpp (original)
+++ sandbox/itl/boost/validate/laws/monoid.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_monoid_hpp_JOFA_070411__
#define __itl_monoid_hpp_JOFA_070411__
Modified: sandbox/itl/boost/validate/laws/order.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/order.hpp (original)
+++ sandbox/itl/boost/validate/laws/order.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_order_h_JOFA_071129__
#define __itl_order_h_JOFA_071129__
@@ -83,8 +83,8 @@
// ---------------------------------------------------------------------------
template <typename Type,
- template<class>class Relation,
- template<class>class Equality = itl::std_equal>
+ template<class>class Relation,
+ template<class>class Equality = itl::std_equal>
class Antisymmetry
: public Law<Antisymmetry<Type,Relation,Equality>,
LOKI_TYPELIST_2(Type,Type), Loki::NullType>
Modified: sandbox/itl/boost/validate/laws/pushouts.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/pushouts.hpp (original)
+++ sandbox/itl/boost/validate/laws/pushouts.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_pushouts_h_JOFA_071124__
#define __itl_pushouts_h_JOFA_071124__
Modified: sandbox/itl/boost/validate/laws/set_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/set_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/set_laws.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_set_laws_h_JOFA_071124__
#define __itl_set_laws_h_JOFA_071124__
@@ -126,7 +126,7 @@
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
{
/** a - (b + c) == (a - b) & (a - c)
- a - (b(1)c) == (a - b)(2)(a - c)
+ a - (b(1)c) == (a - b)(2)(a - c)
computed using inplace operators +=, += and &=
Input = (a := inVal1, b := inVal2, c := inVal3)
Output = (lhs_result, rhs_result)
@@ -207,7 +207,7 @@
return "RightDistributivity<"+type_to_string<Type>::apply()+","
+unary_template_to_string<Operator1>::apply()+","
+unary_template_to_string<Operator2>::apply()+","
- +unary_template_to_string<Equality>::apply() +">";
+ +unary_template_to_string<Equality>::apply() +">";
}
public:
Modified: sandbox/itl/boost/validate/laws/subset_order.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/subset_order.hpp (original)
+++ sandbox/itl/boost/validate/laws/subset_order.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_subset_ordering_hpp_JOFA_090202__
#define __itl_subset_ordering_hpp_JOFA_090202__
@@ -42,36 +42,36 @@
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_inclusion_equal(a, b);
- bool rhs = (a_atomic == b_atomic);
+ bool lhs = is_inclusion_equal(a, b);
+ bool rhs = (a_atomic == b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
bool debug_holds()
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_inclusion_equal(a, b);
- bool rhs = (a_atomic == b_atomic);
+ bool lhs = is_inclusion_equal(a, b);
+ bool rhs = (a_atomic == b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
size_t size()const
@@ -106,39 +106,39 @@
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = is_contained_in(a, b);
- bool rhs = a_atomic.contained_in(b_atomic);
+ bool lhs = is_contained_in(a, b);
+ bool rhs = a_atomic.contained_in(b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
bool debug_holds()
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- cout << "a: " << a << endl;
- cout << "b: " << b << endl;
+ cout << "a: " << a << endl;
+ cout << "b: " << b << endl;
- bool lhs = is_contained_in(a, b);
- bool rhs = a_atomic.contained_in(b_atomic);
+ bool lhs = is_contained_in(a, b);
+ bool rhs = a_atomic.contained_in(b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
@@ -174,36 +174,36 @@
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = contains(a, b);
- bool rhs = a_atomic.contains(b_atomic);
+ bool lhs = contains(a, b);
+ bool rhs = a_atomic.contains(b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
bool debug_holds()
{
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- typename Type::atomized_type a_atomic;
- typename Type::atomized_type b_atomic;
- Interval::atomize(a_atomic, a);
- Interval::atomize(b_atomic, b);
+ typename Type::atomized_type a_atomic;
+ typename Type::atomized_type b_atomic;
+ Interval::atomize(a_atomic, a);
+ Interval::atomize(b_atomic, b);
- bool lhs = contains(a, b);
- bool rhs = a_atomic.contains(b_atomic);
+ bool lhs = contains(a, b);
+ bool rhs = a_atomic.contains(b_atomic);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
- return lhs == rhs;
+ return lhs == rhs;
}
Modified: sandbox/itl/boost/validate/laws/symmetric_difference.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/symmetric_difference.hpp (original)
+++ sandbox/itl/boost/validate/laws/symmetric_difference.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_symmetric_difference_hpp_JOFA_071124__
#define __itl_symmetric_difference_hpp_JOFA_071124__
@@ -40,7 +40,7 @@
public:
- bool holds()
+ bool holds()
{
// --- left hand side ------------------------
Type a_plus_b = this->template getInputValue<operand_a>();
@@ -137,7 +137,7 @@
public:
- bool holds()
+ bool holds()
{
// --- left hand side ------------------------
Type lhs = this->template getInputValue<operand_a>();
Modified: sandbox/itl/boost/validate/loki_xt/Tuple.h
==============================================================================
--- sandbox/itl/boost/validate/loki_xt/Tuple.h (original)
+++ sandbox/itl/boost/validate/loki_xt/Tuple.h 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
// This code is based on and inspired by designs of:
// The Loki Library by Andrei Alexandrescu et al.
// See:
Modified: sandbox/itl/boost/validate/loki_xt/TupleGentor.h
==============================================================================
--- sandbox/itl/boost/validate/loki_xt/TupleGentor.h (original)
+++ sandbox/itl/boost/validate/loki_xt/TupleGentor.h 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
// This code is based on and inspired by designs of:
// The Loki Library by Andrei Alexandrescu et al.
// See:
Modified: sandbox/itl/boost/validate/loki_xt/TypelistGentor.h
==============================================================================
--- sandbox/itl/boost/validate/loki_xt/TypelistGentor.h (original)
+++ sandbox/itl/boost/validate/loki_xt/TypelistGentor.h 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
// This code is based on and inspired by designs of:
// The Loki Library by Andrei Alexandrescu et al.
// See:
Modified: sandbox/itl/boost/validate/type/nat.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/nat.hpp (original)
+++ sandbox/itl/boost/validate/type/nat.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
@@ -22,44 +22,44 @@
class nat
{
public:
- nat(): _value(0) {}
- nat(int val): _value(val<0 ? 0 : val){}
- nat(const nat& val): _value(val._value){}
-
- int value()const { return _value; }
-
- nat& operator++(){ ++_value; return *this; }
- const nat operator++(int){ nat that = *this; ++_value; return that; }
-
- nat& operator--(){ if(_value > 0)--_value; return *this; }
- const nat operator--(int){ nat that = *this; --_value; return that; }
-
- nat& operator += (const nat& right){ _value += right._value; return *this; }
-
- nat& operator -= (const nat& right)
- {
- _value = right._value > _value ? 0 : (_value - right._value);
- return *this;
- }
-
- nat& operator ^= (const nat& right) //JODO should not be required
- {
- _value ^= right._value;
- return *this;
- }
- nat& operator &= (const nat& right) //JODO should not be required
- {
- _value &= right._value;
- return *this;
- }
+ nat(): _value(0) {}
+ nat(int val): _value(val<0 ? 0 : val){}
+ nat(const nat& val): _value(val._value){}
+
+ int value()const { return _value; }
+
+ nat& operator++(){ ++_value; return *this; }
+ const nat operator++(int){ nat that = *this; ++_value; return that; }
+
+ nat& operator--(){ if(_value > 0)--_value; return *this; }
+ const nat operator--(int){ nat that = *this; --_value; return that; }
+
+ nat& operator += (const nat& right){ _value += right._value; return *this; }
+
+ nat& operator -= (const nat& right)
+ {
+ _value = right._value > _value ? 0 : (_value - right._value);
+ return *this;
+ }
+
+ nat& operator ^= (const nat& right) //JODO should not be required
+ {
+ _value ^= right._value;
+ return *this;
+ }
+ nat& operator &= (const nat& right) //JODO should not be required
+ {
+ _value &= right._value;
+ return *this;
+ }
- //CL
- operator int()const{ return (_value); }
+ //CL
+ operator int()const{ return (_value); }
- std::string as_string()const { return to_string<int>::apply(_value); }
+ std::string as_string()const { return to_string<int>::apply(_value); }
private:
- int _value;
+ int _value;
};
//inline nat operator + (const nat& left, const nat& right){return nat(left)+=right;}
Modified: sandbox/itl/boost/validate/utility.hpp
==============================================================================
--- sandbox/itl/boost/validate/utility.hpp (original)
+++ sandbox/itl/boost/validate/utility.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
Modified: sandbox/itl/boost/validate/validater/algebra_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/algebra_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/algebra_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/itl/type_traits/is_continuous.hpp>
@@ -31,18 +31,18 @@
virtual bool hasValidProfile()const{ return true; }
- static int share(int total, int& index, int& rest_shares);
+ static int share(int total, int& index, int& rest_shares);
};
- inline int algebra_validater::share(int total, int& index, int& rest_shares)
- {
- BOOST_ASSERT(index_ == index);
- int count = total - index;
- int share = rest_shares / count;
- rest_shares -= share;
- ++index;
- return share;
- }
+ inline int algebra_validater::share(int total, int& index, int& rest_shares)
+ {
+ BOOST_ASSERT(index_ == index);
+ int count = total - index;
+ int share = rest_shares / count;
+ rest_shares -= share;
+ ++index;
+ return share;
+ }
}} // namespace itl boost
Modified: sandbox/itl/boost/validate/validater/collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/collector_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/itl/functors.hpp>
@@ -34,7 +34,7 @@
inplacePlusCommutativity,
inplaceEtAssociativity,
inplaceEtCommutativity,
- inplaceNaturalInversion,
+ inplaceNaturalInversion,
inplaceSymmetricDifference,
inplaceFlip,
inplacePlusDistributivity,
@@ -50,15 +50,15 @@
void setProfile()
{
- const int sum_of_shares = 100;
+ const int sum_of_shares = 100;
_lawChoice.setSize(Laws_size);
_lawChoice.setMaxWeights(sum_of_shares);
- int rest_shares = sum_of_shares, item_index = 0;
+ int rest_shares = sum_of_shares, item_index = 0;
_lawChoice[inplacePlusAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusNeutrality] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusCommutativity] = share(Laws_size, item_index, rest_shares);
- _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceEtCommutativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceNaturalInversion] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceSymmetricDifference] = share(Laws_size, item_index, rest_shares);
@@ -86,18 +86,18 @@
case inplaceFlip: return new LawValidater<InplaceFlip<Type>, RandomGentor>;
case inplaceEtDistributivity:
if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
- return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal>, RandomGentor>;
- else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal>, RandomGentor>;
+ return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal>, RandomGentor>;
case inplacePlusDashRightDistrib:
if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
- return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal>, RandomGentor>;
- else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal>, RandomGentor>;
- case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus>, RandomGentor>;
- case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal>, RandomGentor>;
+ return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal>, RandomGentor>;
+ case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus>, RandomGentor>;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal>, RandomGentor>;
case inplaceEtDeMorgan:
if(itl::is_interval_splitter<Type>::value || itl::is_interval_separator<Type>::value)
- return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::element_equal>, RandomGentor>;
- else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::std_equal>, RandomGentor>;
+ return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::std_equal>, RandomGentor>;
default: return NULL;
}
Modified: sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/mpl/bool.hpp>
Modified: sandbox/itl/boost/validate/validater/itl_induced_relations.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/itl_induced_relations.hpp (original)
+++ sandbox/itl/boost/validate/validater/itl_induced_relations.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/itl/functors.hpp>
@@ -36,7 +36,7 @@
void setProfile()
{
- const int volume = 100;
+ const int volume = 100;
_lawChoice.setSize(Laws_size);
_lawChoice.setMaxWeights(volume);
_lawChoice[atomize_subset] = 33;
Modified: sandbox/itl/boost/validate/validater/itl_order_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/itl_order_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/itl_order_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/mpl/bool.hpp>
@@ -28,7 +28,7 @@
public:
typedef strict_weak_order_validater<Type, std::less> LessValidaterT;
typedef partial_order_validater<Type, std::less_equal> LessEqualValidaterT;
- typedef partial_order_validater<Type, itl::sub_super_set, itl::element_equal> ContainedInValidaterT;
+ typedef partial_order_validater<Type, itl::sub_super_set, itl::element_equal> ContainedInValidaterT;
enum Laws
{
@@ -42,7 +42,7 @@
void setProfile()
{
- const int sum_of_weights = 100;
+ const int sum_of_weights = 100;
_lawChoice.setSize(sum_of_weights);
_lawChoice.setMaxWeights(sum_of_weights);
_lawChoice[strictWeakStdOrder] = 33;
Modified: sandbox/itl/boost/validate/validater/itl_set_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/itl_set_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/itl_set_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/itl/functors.hpp>
@@ -34,7 +34,7 @@
inplacePlusCommutativity,
inplaceEtAssociativity,
inplaceEtCommutativity,
- inplaceNaturalInversion,
+ inplaceNaturalInversion,
inplaceSymmetricDifference,
inplaceFlip,
inplacePlusDistributivity,
@@ -50,15 +50,15 @@
void setProfile()
{
- const int sum_of_shares = 100;
+ const int sum_of_shares = 100;
_lawChoice.setSize(Laws_size);
_lawChoice.setMaxWeights(sum_of_shares);
- int rest_shares = sum_of_shares, item_index = 0;
+ int rest_shares = sum_of_shares, item_index = 0;
_lawChoice[inplacePlusAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusNeutrality] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusCommutativity] = share(Laws_size, item_index, rest_shares);
- _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceEtCommutativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceNaturalInversion] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceSymmetricDifference] = share(Laws_size, item_index, rest_shares);
@@ -86,18 +86,18 @@
case inplaceFlip: return new LawValidater<InplaceFlip<Type>, RandomGentor>;
case inplaceEtDistributivity:
if(itl::is_interval_splitter<Type>::value)
- return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal>, RandomGentor>;
- else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal>, RandomGentor>;
+ return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal>, RandomGentor>;
case inplacePlusDashRightDistrib:
if(itl::is_interval_splitter<Type>::value)
- return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal>, RandomGentor>;
- else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal>, RandomGentor>;
- case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus>, RandomGentor>;
- case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal>, RandomGentor>;
+ return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal>, RandomGentor>;
+ case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus>, RandomGentor>;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal>, RandomGentor>;
case inplaceEtDeMorgan:
if(itl::is_interval_splitter<Type>::value || itl::is_interval_separator<Type>::value)
- return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::element_equal>, RandomGentor>;
- else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::std_equal>, RandomGentor>;
+ return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::std_equal>, RandomGentor>;
default: return NULL;
}
Modified: sandbox/itl/boost/validate/validater/law_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/law_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/law_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <iostream>
Modified: sandbox/itl/boost/validate/validater/partial_order_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/partial_order_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/partial_order_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/mpl/bool.hpp>
@@ -22,7 +22,7 @@
{
typedef WeightedNumberGentor<int> ChoiceT;
- template <typename Type, template<class>class Relation, template<class>class Equality = itl::std_equal>
+ template <typename Type, template<class>class Relation, template<class>class Equality = itl::std_equal>
class partial_order_validater : public algebra_validater
{
public:
Modified: sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/itl/functors.hpp>
@@ -49,27 +49,27 @@
void setProfile()
{
- const int sum_of_shares = 100;
- const int law_share = sum_of_shares / Laws_size;
- int et_assoc_share = law_share;
- int inv_ex_share = law_share;
+ const int sum_of_shares = 100;
+ const int law_share = sum_of_shares / Laws_size;
+ int et_assoc_share = law_share;
+ int inv_ex_share = law_share;
_lawChoice.setSize(Laws_size);
_lawChoice.setMaxWeights(sum_of_shares);
- //NOTE: Associativity is not valid for partial_absorber signed quantifier maps
- if(!is_total<Type>::value && absorbs_neutrons<Type>::value)
- et_assoc_share = 0;
- //NOTE: An Inverse exists only for a total signed quantifier
- if(!is_total<Type>::value)
- inv_ex_share = 0;
+ //NOTE: Associativity is not valid for partial_absorber signed quantifier maps
+ if(!is_total<Type>::value && absorbs_neutrons<Type>::value)
+ et_assoc_share = 0;
+ //NOTE: An Inverse exists only for a total signed quantifier
+ if(!is_total<Type>::value)
+ inv_ex_share = 0;
- int rest_shares = sum_of_shares, item_index = 0;
+ int rest_shares = sum_of_shares, item_index = 0;
- _lawChoice[inplaceEtAssociativity] = et_assoc_share; rest_shares -= et_assoc_share;
- _lawChoice[inplaceInverseExistence] = inv_ex_share; rest_shares -= inv_ex_share;
+ _lawChoice[inplaceEtAssociativity] = et_assoc_share; rest_shares -= et_assoc_share;
+ _lawChoice[inplaceInverseExistence] = inv_ex_share; rest_shares -= inv_ex_share;
- item_index = 2;
+ item_index = 2;
_lawChoice[inplacePlusAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusNeutrality] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusCommutativity] = share(Laws_size, item_index, rest_shares);
@@ -87,30 +87,30 @@
switch(_lawChoice.some())
{
case inplacePlusAssociativity:
- if(is_interval_splitter<Type>::value)
- return new LawValidater<InplaceAssociativity<Type, inplace_plus, element_equal>, RandomGentor>;
- else return new LawValidater<InplaceAssociativity<Type, inplace_plus, std_equal>, RandomGentor>;
+ if(is_interval_splitter<Type>::value)
+ return new LawValidater<InplaceAssociativity<Type, inplace_plus, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceAssociativity<Type, inplace_plus, std_equal>, RandomGentor>;
case inplacePlusNeutrality: return new LawValidater<InplaceNeutrality <Type>, RandomGentor>;
case inplacePlusCommutativity: return new LawValidater<InplaceCommutativity<Type>, RandomGentor>;
case inplaceEtAssociativity:
- if(absorbs_neutrons<Type>::value && is_total<Type>::value)
- return new LawValidater<InplaceAssociativity<Type, inplace_et, element_equal>, RandomGentor>;
- else return new LawValidater<InplaceAssociativity<Type, inplace_et>, RandomGentor>;
+ if(absorbs_neutrons<Type>::value && is_total<Type>::value)
+ return new LawValidater<InplaceAssociativity<Type, inplace_et, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceAssociativity<Type, inplace_et>, RandomGentor>;
case inplaceEtCommutativity: return new LawValidater<InplaceCommutativity<Type, inplace_et>, RandomGentor>;
case inplaceNaturalInversion:
- if(absorbs_neutrons<Type>::value)
- return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor>;
- else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal>, RandomGentor>;
+ if(absorbs_neutrons<Type>::value)
+ return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor>;
+ else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal>, RandomGentor>;
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type>, RandomGentor>;
case inplaceFlip: return new LawValidater<InplaceFlip<Type>, RandomGentor>;
case sectionAbsorbtion:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_neutrons<Type>::value)
return new LawValidater<SectionAbsorbtion<Type,std_equal>, RandomGentor>;
- else return new LawValidater<SectionAbsorbtion<Type,protonic_equal>, RandomGentor>;
+ else return new LawValidater<SectionAbsorbtion<Type,protonic_equal>, RandomGentor>;
case inplaceInverseExistence:
- if(absorbs_neutrons<Type>::value)
- return new LawValidater<InplaceInverseExistence<Type, inplace_plus, std_equal>, RandomGentor>;
- else return new LawValidater<InplaceInverseExistence<Type, inplace_plus, protonic_equal>, RandomGentor>;
+ if(absorbs_neutrons<Type>::value)
+ return new LawValidater<InplaceInverseExistence<Type, inplace_plus, std_equal>, RandomGentor>;
+ else return new LawValidater<InplaceInverseExistence<Type, inplace_plus, protonic_equal>, RandomGentor>;
default: return NULL;
}
}
Modified: sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/mpl/bool.hpp>
Modified: sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#pragma once
#include <boost/itl/functors.hpp>
@@ -36,7 +36,7 @@
inplaceEtAssociativity,
inplaceEtCommutativity,
inplaceNaturalInversion,
- sectionAbsorbtion,
+ sectionAbsorbtion,
Laws_size
};
@@ -44,17 +44,17 @@
void setProfile()
{
- const int sum_of_shares = 100;
- const int law_share = sum_of_shares / Laws_size;
+ const int sum_of_shares = 100;
+ const int law_share = sum_of_shares / Laws_size;
_lawChoice.setSize(Laws_size);
_lawChoice.setMaxWeights(sum_of_shares);
- int rest_shares = sum_of_shares, item_index = 0;
+ int rest_shares = sum_of_shares, item_index = 0;
_lawChoice[inplacePlusAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusNeutrality] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplacePlusCommutativity] = share(Laws_size, item_index, rest_shares);
- _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceEtCommutativity] = share(Laws_size, item_index, rest_shares);
_lawChoice[inplaceNaturalInversion] = share(Laws_size, item_index, rest_shares);
_lawChoice[sectionAbsorbtion] = share(Laws_size, item_index, rest_shares);
@@ -72,13 +72,13 @@
case inplaceEtAssociativity: return new LawValidater<InplaceAssociativity<Type, inplace_et>, RandomGentor>;
case inplaceEtCommutativity: return new LawValidater<InplaceCommutativity<Type, inplace_et>, RandomGentor>;
case inplaceNaturalInversion:
- if(absorbs_neutrons<Type>::value)
- return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor>;
- else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal>, RandomGentor>;
+ if(absorbs_neutrons<Type>::value)
+ return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor>;
+ else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal>, RandomGentor>;
case sectionAbsorbtion:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_neutrons<Type>::value)
return new LawValidater<SectionAbsorbtion<Type,std_equal>, RandomGentor>;
- else return new LawValidater<SectionAbsorbtion<Type,protonic_equal>, RandomGentor>;
+ else return new LawValidater<SectionAbsorbtion<Type,protonic_equal>, RandomGentor>;
default: return NULL;
}
}
Modified: sandbox/itl/libs/itl/example/boost_party/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party/boost_party.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,7 +1,7 @@
/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
@@ -116,8 +116,8 @@
time_from_string("2008-05-20 19:30"),
time_from_string("2008-05-20 23:00")),
180)
- //, inplace_max<int>()
- );
+ //, inplace_max<int>()
+ );
tallest_guest.add(
make_pair(
@@ -125,8 +125,8 @@
time_from_string("2008-05-20 20:10"),
time_from_string("2008-05-21 00:00")),
170)
- //, inplace_max<int>()
- );
+ //, inplace_max<int>()
+ );
tallest_guest.add(
make_pair(
@@ -134,8 +134,8 @@
time_from_string("2008-05-20 22:15"),
time_from_string("2008-05-21 00:30")),
200)
- //, inplace_max<int>()
- );
+ //, inplace_max<int>()
+ );
BoostPartyAttendenceHistoryT::iterator it = party.begin();
Modified: sandbox/itl/libs/itl/example/interval/interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval/interval.cpp (original)
+++ sandbox/itl/libs/itl/example/interval/interval.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,7 +1,7 @@
/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
Modified: sandbox/itl/libs/itl/example/interval/vc9_interval.vcproj
==============================================================================
--- sandbox/itl/libs/itl/example/interval/vc9_interval.vcproj (original)
+++ sandbox/itl/libs/itl/example/interval/vc9_interval.vcproj 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -200,6 +200,10 @@
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
+ <File
+ RelativePath=".\ClassDiagram1.cd"
+ >
+ </File>
</Files>
<Globals>
</Globals>
Modified: sandbox/itl/libs/itl/example/itvset_shell/itvset_shell.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/itvset_shell/itvset_shell.cpp (original)
+++ sandbox/itl/libs/itl/example/itvset_shell/itvset_shell.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -8,10 +8,10 @@
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
itvset_shell.cpp provides a simple test shells for interval sets.
The shell also gives you a good idea how interval container are working.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <boost/itl/split_interval_set.hpp>
Modified: sandbox/itl/libs/itl/example/man_power/man_power.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/man_power/man_power.cpp (original)
+++ sandbox/itl/libs/itl/example/man_power/man_power.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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 man_power.cpp \file man_power.cpp
Interval sets and maps can be filled and manipulated using
Modified: sandbox/itl/libs/itl/example/month_and_week_grid/month_and_week_grid.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/month_and_week_grid/month_and_week_grid.cpp (original)
+++ sandbox/itl/libs/itl/example/month_and_week_grid/month_and_week_grid.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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 month_and_week_grid.cpp \file month_and_week_grid.cpp
As split_interval_set preserves all interval borders on insertion
Modified: sandbox/itl/libs/itl/example/overlap_counter/overlap_counter.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/overlap_counter/overlap_counter.cpp (original)
+++ sandbox/itl/libs/itl/example/overlap_counter/overlap_counter.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <stdio.h>
#include <iostream>
#include <boost/itl/type_traits/to_string.hpp>
Modified: sandbox/itl/libs/itl/example/party/party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/party/party.cpp (original)
+++ sandbox/itl/libs/itl/example/party/party.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <stdio.h>
#include <iostream>
#include <boost/itl/type_traits/to_string.hpp>
Modified: sandbox/itl/libs/itl/example/user_groups/user_groups.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/user_groups/user_groups.cpp (original)
+++ sandbox/itl/libs/itl/example/user_groups/user_groups.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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 user_groups.cpp \file user_groups.cpp
Example user_groups.cpp shows the availability of set operations
Modified: sandbox/itl/libs/itl/test/test_casual/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual/test_casual.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
@@ -31,47 +31,47 @@
BOOST_AUTO_TEST_CASE(subset_test)
{
- typedef interval_map<int,int> IntervalMapT;
- typedef split_interval_map<int,int> SplitIntervalMapT;
-
- SplitIntervalMapT left, right;
- left.add(CDv(2,7,5)).add(IIv(9,9,5));
- right.add(CDv(-8,-6,2)).add(CIv(2,7,5)).add(CDv(7,9,1)).add(IIv(9,11,5));
- BOOST_CHECK_EQUAL(is_contained_in(left,right), true);
-
- left.clear(); right.clear();
- left.add(CIv(-4,-2,1)).add(IIv(8,8,3));
- right.add(CIv(-6,-1,1)).add(CIv(6,9,3));
- is_contained_in(left,right);
- BOOST_CHECK_EQUAL(is_contained_in(left,right), true);
+ typedef interval_map<int,int> IntervalMapT;
+ typedef split_interval_map<int,int> SplitIntervalMapT;
+
+ SplitIntervalMapT left, right;
+ left.add(CDv(2,7,5)).add(IIv(9,9,5));
+ right.add(CDv(-8,-6,2)).add(CIv(2,7,5)).add(CDv(7,9,1)).add(IIv(9,11,5));
+ BOOST_CHECK_EQUAL(is_contained_in(left,right), true);
+
+ left.clear(); right.clear();
+ left.add(CIv(-4,-2,1)).add(IIv(8,8,3));
+ right.add(CIv(-6,-1,1)).add(CIv(6,9,3));
+ is_contained_in(left,right);
+ BOOST_CHECK_EQUAL(is_contained_in(left,right), true);
}
BOOST_AUTO_TEST_CASE(superset_test)
{
- typedef interval_map<int,int> IntervalMapT;
- typedef split_interval_map<int,int> SplitIntervalMapT;
-
- SplitIntervalMapT left, right;
- left.add(IDv(-7,-1,1)).add(IIv(8,16,9));
- right.add(CDv(-8,-4,1)).add(IIv(8,8,9));
- BOOST_CHECK_EQUAL(contains(left,right), true);
+ typedef interval_map<int,int> IntervalMapT;
+ typedef split_interval_map<int,int> SplitIntervalMapT;
+
+ SplitIntervalMapT left, right;
+ left.add(IDv(-7,-1,1)).add(IIv(8,16,9));
+ right.add(CDv(-8,-4,1)).add(IIv(8,8,9));
+ BOOST_CHECK_EQUAL(contains(left,right), true);
}
BOOST_AUTO_TEST_CASE(casual_test)
{
- typedef int T;
- typedef itl::map<int,int> ItlMapT;
- typedef interval_map<int,int> IntervalMapT;
- typedef split_interval_map<int,int> SplitIntervalMapT;
-
- IntervalMapT left, right;
-
- left.add(IDv(1,3,1));
- BOOST_CHECK_EQUAL(IntervalMapT().add(IDv(1,3,1))(2), 1);
- BOOST_CHECK_EQUAL(IntervalMapT().add(IDv(1,3,1))(3) == 1, false);
- BOOST_CHECK_EQUAL(IntervalMapT().add(IDv(1,3,1))(3), 0);
- BOOST_CHECK_EQUAL(SplitIntervalMapT().add(IDv(1,3,1))(2), 1);
- BOOST_CHECK_EQUAL(SplitIntervalMapT().add(IDv(1,3,1))(3) == 1, false);
- BOOST_CHECK_EQUAL(ItlMapT().add(sK_v(2,1))(2), 1);
- BOOST_CHECK_EQUAL(ItlMapT().add(sK_v(2,1))(3) == 1, false);
+ typedef int T;
+ typedef itl::map<int,int> ItlMapT;
+ typedef interval_map<int,int> IntervalMapT;
+ typedef split_interval_map<int,int> SplitIntervalMapT;
+
+ IntervalMapT left, right;
+
+ left.add(IDv(1,3,1));
+ BOOST_CHECK_EQUAL(IntervalMapT().add(IDv(1,3,1))(2), 1);
+ BOOST_CHECK_EQUAL(IntervalMapT().add(IDv(1,3,1))(3) == 1, false);
+ BOOST_CHECK_EQUAL(IntervalMapT().add(IDv(1,3,1))(3), 0);
+ BOOST_CHECK_EQUAL(SplitIntervalMapT().add(IDv(1,3,1))(2), 1);
+ BOOST_CHECK_EQUAL(SplitIntervalMapT().add(IDv(1,3,1))(3) == 1, false);
+ BOOST_CHECK_EQUAL(ItlMapT().add(sK_v(2,1))(2), 1);
+ BOOST_CHECK_EQUAL(ItlMapT().add(sK_v(2,1))(3) == 1, false);
}
Modified: sandbox/itl/libs/itl/test/test_interval_map/test_interval_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map/test_interval_map.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map/test_interval_map.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_interval_map/test_interval_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map/test_interval_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map/test_interval_map_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_interval_map_fundamentals_4_ordered_types, T, ordered_types)
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
@@ -930,15 +930,15 @@
BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
- split_interval_map<T,U> left, right;
- left. add(IDv(0,2,2));
- right.add(IDv(0,2,2));
+ split_interval_map<T,U> left, right;
+ left. add(IDv(0,2,2));
+ right.add(IDv(0,2,2));
BOOST_CHECK_EQUAL( is_element_equal(left, right), true );
- split_interval_set<T> left2, right2;
- left2. add(I_D(0,2));
- right2.add(I_D(0,1));
- is_element_equal(left2, right2);
+ split_interval_set<T> left2, right2;
+ left2. add(I_D(0,2));
+ right2.add(I_D(0,1));
+ is_element_equal(left2, right2);
BOOST_CHECK_EQUAL( is_element_equal(left2, right2), false );
}
@@ -1207,7 +1207,7 @@
split_A.add(I0_3D_1).add(I4_4I_1).add(I6_6I_1);
split_B.add(I4_4I_1).add(I6_6I_1);
- split_A.erase_if(size_greater_1<typename SplitIntervalMapT::value_type>());
+ split_A.erase_if(size_greater_1<typename SplitIntervalMapT::value_type>());
BOOST_CHECK_EQUAL( split_A, split_B );
}
@@ -1215,61 +1215,61 @@
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_map_mixed_infix_plus_overload_4_bicremental_types, T, bicremental_types)
{
typedef int U;
- typedef interval_map<T,U> IntervalMapT;
- interval_map<T,U> join_a;
- split_interval_map<T,U> split_a;
+ typedef interval_map<T,U> IntervalMapT;
+ interval_map<T,U> join_a;
+ split_interval_map<T,U> split_a;
- join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a);
+ BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_map_mixed_infix_pipe_overload_4_bicremental_types, T, bicremental_types)
{
typedef int U;
- typedef interval_map<T,U> IntervalMapT;
- interval_map<T,U> join_a;
- split_interval_map<T,U> split_a;
+ typedef interval_map<T,U> IntervalMapT;
+ interval_map<T,U> join_a;
+ split_interval_map<T,U> split_a;
- join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a);
+ BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_map_mixed_infix_minus_overload_4_bicremental_types, T, bicremental_types)
{
typedef int U;
- typedef interval_map<T,U> IntervalMapT;
- interval_map<T,U> join_a, join_b;
- split_interval_map<T,U> split_a, split_b;
+ typedef interval_map<T,U> IntervalMapT;
+ interval_map<T,U> join_a, join_b;
+ split_interval_map<T,U> split_a, split_b;
- join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- BOOST_CHECK_EQUAL(split_a - join_a, (split_b = split_a) -= join_a);
- BOOST_CHECK_EQUAL(split_a - join_a, split_b);
+ BOOST_CHECK_EQUAL(split_a - join_a, (split_b = split_a) -= join_a);
+ BOOST_CHECK_EQUAL(split_a - join_a, split_b);
- BOOST_CHECK_EQUAL(join_a - split_a, (join_b = join_a) -= split_a);
- BOOST_CHECK_EQUAL(join_a - split_a, join_b);
+ BOOST_CHECK_EQUAL(join_a - split_a, (join_b = join_a) -= split_a);
+ BOOST_CHECK_EQUAL(join_a - split_a, join_b);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_map_mixed_infix_et_overload_4_bicremental_types, T, bicremental_types)
{
typedef int U;
- typedef interval_map<T,U> IntervalMapT;
- interval_map<T,U> join_a, join_b;
- split_interval_map<T,U> split_a, split_b;
-
- join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a);
- BOOST_CHECK_EQUAL(split_a & join_a, (split_b = split_a) &= join_a);
- BOOST_CHECK_EQUAL(split_a & join_a, split_b);
+ typedef interval_map<T,U> IntervalMapT;
+ interval_map<T,U> join_a, join_b;
+ split_interval_map<T,U> split_a, split_b;
+
+ join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a);
+ BOOST_CHECK_EQUAL(split_a & join_a, (split_b = split_a) &= join_a);
+ BOOST_CHECK_EQUAL(split_a & join_a, split_b);
- BOOST_CHECK_EQUAL(join_a & split_a, (split_b = split_a) &= join_a);
- BOOST_CHECK_EQUAL(join_a & split_a, split_b);
+ BOOST_CHECK_EQUAL(join_a & split_a, (split_b = split_a) &= join_a);
+ BOOST_CHECK_EQUAL(join_a & split_a, split_b);
}
Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_interval_map_shared_h_JOFA_081005__
#define __test_itl_interval_map_shared_h_JOFA_081005__
@@ -594,7 +594,7 @@
map_AB = map_A;
map_AB &= v1;
map_ab.clear();
- map_ab.add(mapping_pair<T,U>(v1,u1));
+ map_ab.add(mapping_pair<T,U>(v1,u1));
BOOST_CHECK_EQUAL( map_AB, map_ab );
}
@@ -801,17 +801,17 @@
class T, class U>
void interval_map_flip_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
- typedef IntervalMapT IMap;
+ typedef IntervalMap<T,U> IntervalMapT;
+ typedef IntervalMapT IMap;
- IntervalMapT set_a, set_b, lhs, rhs;
- //[0 2)
- // 1
- // [1 3)
- // 1
- //[0 1) [2 3) : {[0 2)->1} ^= ([2 3)->1)
- // 1 1
- BOOST_CHECK_EQUAL(IMap(IDv(0,2,1)) ^= (IDv(1,3,1)), IMap(IDv(0,1,1)) + IDv(2,3,1));
+ IntervalMapT set_a, set_b, lhs, rhs;
+ //[0 2)
+ // 1
+ // [1 3)
+ // 1
+ //[0 1) [2 3) : {[0 2)->1} ^= ([2 3)->1)
+ // 1 1
+ BOOST_CHECK_EQUAL(IMap(IDv(0,2,1)) ^= (IDv(1,3,1)), IMap(IDv(0,1,1)) + IDv(2,3,1));
}
template <template<class T, class U,
@@ -825,20 +825,20 @@
class T, class U>
void interval_map_infix_plus_overload_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
-
- IntervalMapT map_a, map_b;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- BOOST_CHECK_EQUAL(map_a + map_b, map_b + map_a);
- //This checks all cases of is_interval_map_derivative<T>
- BOOST_CHECK_EQUAL(map_a + val_pair1, val_pair1 + map_a);
- BOOST_CHECK_EQUAL(map_b + val_pair2, val_pair2 + map_b);
- BOOST_CHECK_EQUAL(map_b + map_pair, map_pair + map_b);
+ typedef IntervalMap<T,U> IntervalMapT;
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
+
+ IntervalMapT map_a, map_b;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ BOOST_CHECK_EQUAL(map_a + map_b, map_b + map_a);
+ //This checks all cases of is_interval_map_derivative<T>
+ BOOST_CHECK_EQUAL(map_a + val_pair1, val_pair1 + map_a);
+ BOOST_CHECK_EQUAL(map_b + val_pair2, val_pair2 + map_b);
+ BOOST_CHECK_EQUAL(map_b + map_pair, map_pair + map_b);
}
template <template<class T, class U,
@@ -852,20 +852,20 @@
class T, class U>
void interval_map_infix_pipe_overload_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
-
- IntervalMapT map_a, map_b;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- BOOST_CHECK_EQUAL(map_a | map_b, map_b | map_a);
- //This checks all cases of is_interval_map_derivative<T>
- BOOST_CHECK_EQUAL(map_a | val_pair1, val_pair1 | map_a);
- BOOST_CHECK_EQUAL(map_b | val_pair2, val_pair2 | map_b);
- BOOST_CHECK_EQUAL(map_b | map_pair, map_pair | map_b);
+ typedef IntervalMap<T,U> IntervalMapT;
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
+
+ IntervalMapT map_a, map_b;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ BOOST_CHECK_EQUAL(map_a | map_b, map_b | map_a);
+ //This checks all cases of is_interval_map_derivative<T>
+ BOOST_CHECK_EQUAL(map_a | val_pair1, val_pair1 | map_a);
+ BOOST_CHECK_EQUAL(map_b | val_pair2, val_pair2 | map_b);
+ BOOST_CHECK_EQUAL(map_b | map_pair, map_pair | map_b);
}
@@ -881,44 +881,44 @@
class T, class U>
void interval_map_infix_minus_overload_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
+ typedef IntervalMap<T,U> IntervalMapT;
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
-
- itl::interval<T> itv = C_D(4,11);
- typename IntervalMapT::interval_mapping_type itv_v = CDv(4,11,3);
-
- IntervalMapT map_a, map_b, map_c;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- map_c = map_a;
-
- interval_set<T> join_set_a;
- separate_interval_set<T> sep_set_a;
- split_interval_set<T> split_set_a;
- join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
- sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
- split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- //Happy day overloading
- BOOST_CHECK_EQUAL(map_a - map_b, (map_c = map_a) -= map_b);
- BOOST_CHECK_EQUAL(map_a - map_b, map_c);
-
- //This checks all cases of is_interval_map_derivative<T>
- BOOST_CHECK_EQUAL((map_a - val_pair1) + val_pair1, (map_a + val_pair1) - val_pair1);
- BOOST_CHECK_EQUAL((map_b - val_pair2) + val_pair2, (map_b + val_pair2) - val_pair2);
- BOOST_CHECK_EQUAL((map_b - map_pair) + map_pair, (map_b + map_pair) - map_pair);
-
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(map_a - itv, (map_a + itv_v) - itv);
- BOOST_CHECK_EQUAL(map_b - MK_v(8), (IIv(8,8,3) + map_b) - MK_v(8));
-
- //This checks all cases of is_interval_set_companion<T>
- BOOST_CHECK_EQUAL(map_a - split_set_a, ((split_set_a & map_a) + map_a) - split_set_a);
- BOOST_CHECK_EQUAL(map_a - sep_set_a, ((sep_set_a & map_a) + map_a) - sep_set_a);
- BOOST_CHECK_EQUAL(map_a - join_set_a, ((join_set_a & map_a) + map_a) - join_set_a);
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
+
+ itl::interval<T> itv = C_D(4,11);
+ typename IntervalMapT::interval_mapping_type itv_v = CDv(4,11,3);
+
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ map_c = map_a;
+
+ interval_set<T> join_set_a;
+ separate_interval_set<T> sep_set_a;
+ split_interval_set<T> split_set_a;
+ join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
+ sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
+ split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ //Happy day overloading
+ BOOST_CHECK_EQUAL(map_a - map_b, (map_c = map_a) -= map_b);
+ BOOST_CHECK_EQUAL(map_a - map_b, map_c);
+
+ //This checks all cases of is_interval_map_derivative<T>
+ BOOST_CHECK_EQUAL((map_a - val_pair1) + val_pair1, (map_a + val_pair1) - val_pair1);
+ BOOST_CHECK_EQUAL((map_b - val_pair2) + val_pair2, (map_b + val_pair2) - val_pair2);
+ BOOST_CHECK_EQUAL((map_b - map_pair) + map_pair, (map_b + map_pair) - map_pair);
+
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(map_a - itv, (map_a + itv_v) - itv);
+ BOOST_CHECK_EQUAL(map_b - MK_v(8), (IIv(8,8,3) + map_b) - MK_v(8));
+
+ //This checks all cases of is_interval_set_companion<T>
+ BOOST_CHECK_EQUAL(map_a - split_set_a, ((split_set_a & map_a) + map_a) - split_set_a);
+ BOOST_CHECK_EQUAL(map_a - sep_set_a, ((sep_set_a & map_a) + map_a) - sep_set_a);
+ BOOST_CHECK_EQUAL(map_a - join_set_a, ((join_set_a & map_a) + map_a) - join_set_a);
}
@@ -933,41 +933,41 @@
class T, class U>
void interval_map_infix_et_overload_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
+ typedef IntervalMap<T,U> IntervalMapT;
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
-
- itl::interval<T> itv = C_D(4,11);
-
- IntervalMapT map_a, map_b;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- interval_set<T> join_set_a;
- separate_interval_set<T> sep_set_a;
- split_interval_set<T> split_set_a;
- join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
- sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
- split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- //Happy day overloading
- BOOST_CHECK_EQUAL(map_a & map_b, map_b & map_a);
-
- //This checks all cases of is_interval_map_derivative<T>
- BOOST_CHECK_EQUAL(map_a & val_pair1, val_pair1 & map_a);
- BOOST_CHECK_EQUAL(map_b & val_pair2, val_pair2 & map_b);
- BOOST_CHECK_EQUAL(map_b & map_pair, map_pair & map_b);
-
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(map_a & itv, itv & map_a);
- BOOST_CHECK_EQUAL(map_b & MK_v(8), MK_v(8) & map_b);
-
- //This checks all cases of is_interval_set_companion<T>
- BOOST_CHECK_EQUAL(map_a & split_set_a, split_set_a & map_a);
- BOOST_CHECK_EQUAL(map_a & sep_set_a, sep_set_a & map_a);
- BOOST_CHECK_EQUAL(map_a & join_set_a, join_set_a & map_a);
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
+
+ itl::interval<T> itv = C_D(4,11);
+
+ IntervalMapT map_a, map_b;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ interval_set<T> join_set_a;
+ separate_interval_set<T> sep_set_a;
+ split_interval_set<T> split_set_a;
+ join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
+ sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
+ split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ //Happy day overloading
+ BOOST_CHECK_EQUAL(map_a & map_b, map_b & map_a);
+
+ //This checks all cases of is_interval_map_derivative<T>
+ BOOST_CHECK_EQUAL(map_a & val_pair1, val_pair1 & map_a);
+ BOOST_CHECK_EQUAL(map_b & val_pair2, val_pair2 & map_b);
+ BOOST_CHECK_EQUAL(map_b & map_pair, map_pair & map_b);
+
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(map_a & itv, itv & map_a);
+ BOOST_CHECK_EQUAL(map_b & MK_v(8), MK_v(8) & map_b);
+
+ //This checks all cases of is_interval_set_companion<T>
+ BOOST_CHECK_EQUAL(map_a & split_set_a, split_set_a & map_a);
+ BOOST_CHECK_EQUAL(map_a & sep_set_a, sep_set_a & map_a);
+ BOOST_CHECK_EQUAL(map_a & join_set_a, join_set_a & map_a);
}
@@ -982,32 +982,32 @@
class T, class U>
void interval_map_infix_caret_overload_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
+ typedef IntervalMap<T,U> IntervalMapT;
+
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
+
+ itl::interval<T> itv = C_D(4,11);
+
+ IntervalMapT map_a, map_b;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ interval_set<T> join_set_a;
+ separate_interval_set<T> sep_set_a;
+ split_interval_set<T> split_set_a;
+ join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
+ sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
+ split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ //Happy day overloading
+ BOOST_CHECK_EQUAL(map_a ^ map_b, map_b ^ map_a);
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
-
- itl::interval<T> itv = C_D(4,11);
-
- IntervalMapT map_a, map_b;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- interval_set<T> join_set_a;
- separate_interval_set<T> sep_set_a;
- split_interval_set<T> split_set_a;
- join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
- sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
- split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- //Happy day overloading
- BOOST_CHECK_EQUAL(map_a ^ map_b, map_b ^ map_a);
-
- //This checks all cases of is_interval_map_derivative<T>
- BOOST_CHECK_EQUAL(map_a ^ val_pair1, val_pair1 ^ map_a);
- BOOST_CHECK_EQUAL(map_b ^ val_pair2, val_pair2 ^ map_b);
- BOOST_CHECK_EQUAL(map_b ^ map_pair, map_pair ^ map_b);
+ //This checks all cases of is_interval_map_derivative<T>
+ BOOST_CHECK_EQUAL(map_a ^ val_pair1, val_pair1 ^ map_a);
+ BOOST_CHECK_EQUAL(map_b ^ val_pair2, val_pair2 ^ map_b);
+ BOOST_CHECK_EQUAL(map_b ^ map_pair, map_pair ^ map_b);
}
template <template<class T, class U,
@@ -1021,24 +1021,24 @@
class T, class U>
void interval_map_find_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
+ typedef IntervalMap<T,U> IntervalMapT;
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
- IntervalMapT map_a;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+ IntervalMapT map_a;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- IntervalMapT::const_iterator found = map_a.find(MK_v(6));
+ IntervalMapT::const_iterator found = map_a.find(MK_v(6));
- BOOST_CHECK_EQUAL( found->CONT_VALUE, MK_u(3) );
- BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
+ BOOST_CHECK_EQUAL( found->CONT_VALUE, MK_u(3) );
+ BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
- found = map_a.find(MK_v(5));
+ found = map_a.find(MK_v(5));
- BOOST_CHECK_EQUAL( found == map_a.end(), true );
- BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
+ BOOST_CHECK_EQUAL( found == map_a.end(), true );
+ BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
}
@@ -1053,18 +1053,18 @@
class T, class U>
void interval_map_set_4_bicremental_types()
{
- typedef IntervalMap<T,U> IntervalMapT;
+ typedef IntervalMap<T,U> IntervalMapT;
- typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
- std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
- mapping_pair<T,U> map_pair = K_v(4,3);
-
- IntervalMapT map_a;
- map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
-
- BOOST_CHECK_EQUAL( map_a.set(CDv(2,10,4)).contains(CDv(2,10,4)), true );
- BOOST_CHECK_EQUAL( map_a.set(K_v(4,5)).contains(K_v(4,5)), true );
- BOOST_CHECK_EQUAL( map_a.set(K_v(4,5)).set(CDv(3,5,6)).contains(CDv(3,5,6)), true );
+ typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
+ std::pair<const interval<T>, U> val_pair2 = IDv(3,5,3);
+ mapping_pair<T,U> map_pair = K_v(4,3);
+
+ IntervalMapT map_a;
+ map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
+
+ BOOST_CHECK_EQUAL( map_a.set(CDv(2,10,4)).contains(CDv(2,10,4)), true );
+ BOOST_CHECK_EQUAL( map_a.set(K_v(4,5)).contains(K_v(4,5)), true );
+ BOOST_CHECK_EQUAL( map_a.set(K_v(4,5)).set(CDv(3,5,6)).contains(CDv(3,5,6)), true );
}
#endif // __test_itl_interval_map_shared_h_JOFA_080920__
Modified: sandbox/itl/libs/itl/test/test_interval_set/test_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set/test_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set/test_interval_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_interval_set/test_interval_set_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set/test_interval_set_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set/test_interval_set_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_interval_set_fundamentals_4_ordered_types, T, ordered_types)
Modified: sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_laws/test_interval_set_laws_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_interval_set_laws_shared_h_JOFA_090201__
#define __test_itl_interval_set_laws_shared_h_JOFA_090201__
@@ -23,16 +23,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
- CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
+ CHECK_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
+ CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
}
@@ -47,16 +47,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, segm, elem);
- CHECK_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, segm, elem);
+ CHECK_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, segm, elem);
+ CHECK_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, segm, elem);
}
//------------------------------------------------------------------------------
@@ -74,16 +74,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
}
@@ -98,16 +98,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, segm, elem);
}
@@ -125,16 +125,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
}
//------------------------------------------------------------------------------
@@ -151,19 +151,19 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(set_a, set_b, set_c, segm, elem);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, set_a, set_b, set_c, segm, elem);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, set_a, set_b, set_c, segm, elem);
}
@@ -181,16 +181,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
}
//------------------------------------------------------------------------------
@@ -207,19 +207,19 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type segm = I_D(6,9);
- T elem = make<T>(5);
+ typename IntervalSetT::segment_type segm = I_D(6,9);
+ T elem = make<T>(5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, set_a, set_b, set_c, segm, elem);
}
#endif // __test_itl_interval_set_laws_shared_h_JOFA_090201__
Modified: sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
@@ -238,18 +238,18 @@
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_set_mixed_contains_4_bicremental_types, T, bicremental_types)
{
- split_interval_set<T> split_set;
- split_set.add(I_D(0,4)).add(I_D(4,8));
+ split_interval_set<T> split_set;
+ split_set.add(I_D(0,4)).add(I_D(4,8));
BOOST_CHECK_EQUAL( split_set.contains(MK_v(4)), true );
BOOST_CHECK_EQUAL( split_set.contains(C_D(2,5)), true );
- interval_set<T> join_set_gap4(split_set.erase(MK_v(4)));
+ interval_set<T> join_set_gap4(split_set.erase(MK_v(4)));
BOOST_CHECK_EQUAL( join_set_gap4.contains(MK_v(4)), false );
BOOST_CHECK_EQUAL( join_set_gap4.contains(C_D(2,5)), false );
BOOST_CHECK_EQUAL( split_set.contains(split_set), true );
BOOST_CHECK_EQUAL( split_set.contains(join_set_gap4), true );
-
+
}
@@ -761,79 +761,79 @@
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_set_mixed_infix_plus_overload_4_bicremental_types, T, bicremental_types)
{
- interval_set<T> join_a;
- separate_interval_set<T> sep_a;
- split_interval_set<T> split_a;
-
- join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
- sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
- split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- BOOST_CHECK_EQUAL(split_a + sep_a, sep_a + split_a );
- BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a);
- BOOST_CHECK_EQUAL(sep_a + join_a, join_a + sep_a );
+ interval_set<T> join_a;
+ separate_interval_set<T> sep_a;
+ split_interval_set<T> split_a;
+
+ join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
+ sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
+ split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ BOOST_CHECK_EQUAL(split_a + sep_a, sep_a + split_a );
+ BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a);
+ BOOST_CHECK_EQUAL(sep_a + join_a, join_a + sep_a );
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_set_mixed_infix_pipe_overload_4_bicremental_types, T, bicremental_types)
{
- interval_set<T> join_a;
- separate_interval_set<T> sep_a;
- split_interval_set<T> split_a;
-
- join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
- sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
- split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- BOOST_CHECK_EQUAL(split_a | sep_a, sep_a | split_a );
- BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a);
- BOOST_CHECK_EQUAL(sep_a | join_a, join_a | sep_a );
+ interval_set<T> join_a;
+ separate_interval_set<T> sep_a;
+ split_interval_set<T> split_a;
+
+ join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
+ sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
+ split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ BOOST_CHECK_EQUAL(split_a | sep_a, sep_a | split_a );
+ BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a);
+ BOOST_CHECK_EQUAL(sep_a | join_a, join_a | sep_a );
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_set_mixed_infix_minus_overload_4_bicremental_types, T, bicremental_types)
{
- interval_set<T> join_a, join_b;
- separate_interval_set<T> sep_a, sep_b;
- split_interval_set<T> split_a, split_b;
-
- join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
- sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
- split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- BOOST_CHECK_EQUAL(split_a - sep_a, (split_b = split_a) -= sep_a );
- BOOST_CHECK_EQUAL(split_a - join_a, (split_b = split_a) -= join_a );
- BOOST_CHECK_EQUAL(sep_a - join_a, (sep_b = sep_a) -= join_a );
-
- BOOST_CHECK_EQUAL(sep_a - split_a, (sep_b = sep_a) -= split_a);
- BOOST_CHECK_EQUAL(join_a - split_a, (join_b = join_a) -= split_a);
- BOOST_CHECK_EQUAL(join_a - sep_a, (join_b = join_a) -= sep_a );
+ interval_set<T> join_a, join_b;
+ separate_interval_set<T> sep_a, sep_b;
+ split_interval_set<T> split_a, split_b;
+
+ join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
+ sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
+ split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ BOOST_CHECK_EQUAL(split_a - sep_a, (split_b = split_a) -= sep_a );
+ BOOST_CHECK_EQUAL(split_a - join_a, (split_b = split_a) -= join_a );
+ BOOST_CHECK_EQUAL(sep_a - join_a, (sep_b = sep_a) -= join_a );
+
+ BOOST_CHECK_EQUAL(sep_a - split_a, (sep_b = sep_a) -= split_a);
+ BOOST_CHECK_EQUAL(join_a - split_a, (join_b = join_a) -= split_a);
+ BOOST_CHECK_EQUAL(join_a - sep_a, (join_b = join_a) -= sep_a );
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_set_mixed_infix_et_overload_4_bicremental_types, T, bicremental_types)
{
- interval_set<T> join_a;
- separate_interval_set<T> sep_a;
- split_interval_set<T> split_a;
-
- join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
- sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
- split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- BOOST_CHECK_EQUAL(split_a & sep_a, sep_a & split_a );
- BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a);
- BOOST_CHECK_EQUAL(sep_a & join_a, join_a & sep_a );
+ interval_set<T> join_a;
+ separate_interval_set<T> sep_a;
+ split_interval_set<T> split_a;
+
+ join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
+ sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
+ split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ BOOST_CHECK_EQUAL(split_a & sep_a, sep_a & split_a );
+ BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a);
+ BOOST_CHECK_EQUAL(sep_a & join_a, join_a & sep_a );
}
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_set_mixed_infix_caret_overload_4_bicremental_types, T, bicremental_types)
{
- interval_set<T> join_a;
- separate_interval_set<T> sep_a;
- split_interval_set<T> split_a;
-
- join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
- sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
- split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
-
- BOOST_CHECK_EQUAL(split_a ^ sep_a, sep_a ^ split_a );
- BOOST_CHECK_EQUAL(split_a ^ join_a, join_a ^ split_a);
- BOOST_CHECK_EQUAL(sep_a ^ join_a, join_a ^ sep_a );
+ interval_set<T> join_a;
+ separate_interval_set<T> sep_a;
+ split_interval_set<T> split_a;
+
+ join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
+ sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
+ split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
+
+ BOOST_CHECK_EQUAL(split_a ^ sep_a, sep_a ^ split_a );
+ BOOST_CHECK_EQUAL(split_a ^ join_a, join_a ^ split_a);
+ BOOST_CHECK_EQUAL(sep_a ^ join_a, join_a ^ sep_a );
}
Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,16 +1,16 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_interval_set_shared_h_JOFA_080920__
#define __test_itl_interval_set_shared_h_JOFA_080920__
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -141,7 +141,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -192,7 +192,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -233,7 +233,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -260,7 +260,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -302,7 +302,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -346,52 +346,52 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_element_compare_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- typedef IntervalSet<T> ISet;
+ typedef IntervalSet<T> IntervalSetT;
+ typedef IntervalSet<T> ISet;
- BOOST_CHECK_EQUAL( is_element_equal( ISet(), ISet()), true );
- BOOST_CHECK_EQUAL( is_element_equal( ISet(), ISet(I_D(0,1))), false );
+ BOOST_CHECK_EQUAL( is_element_equal( ISet(), ISet()), true );
+ BOOST_CHECK_EQUAL( is_element_equal( ISet(), ISet(I_D(0,1))), false );
BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,1)), ISet()), false );
BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,1)), ISet(I_D(0,1))), true );
- BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,5)), ISet(I_D(3,8))), false );
- BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(3,8)), ISet(I_D(0,5))), false );
+ BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,5)), ISet(I_D(3,8))), false );
+ BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(3,8)), ISet(I_D(0,5))), false );
- BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,1)), ISet(I_D(0,1)) ), true );
+ BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,1)), ISet(I_D(0,1)) ), true );
BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,1)), ISet(I_D(0,1))+I_D(1,2) ), false );
BOOST_CHECK_EQUAL( is_element_equal( I_D(1,2)+ISet(I_D(0,1)), ISet(I_D(0,1)) ), false );
BOOST_CHECK_EQUAL( is_element_equal( I_D(1,2)+ISet(I_D(0,1)), ISet(I_D(0,1))+I_D(1,2) ), true );
- //[0 1)[1 2)
- //[0 2)
+ //[0 1)[1 2)
+ //[0 2)
BOOST_CHECK_EQUAL( is_element_equal( I_D(0,1)+ISet(I_D(1,2)), ISet(I_D(0,2)) ), true );
BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,2)), ISet(I_D(0,1))+I_D(1,2) ), true );
- //[0 1) [2 3)
- //[0 3)
+ //[0 1) [2 3)
+ //[0 3)
BOOST_CHECK_EQUAL( is_element_equal( I_D(0,1)+ISet(I_D(2,3)), ISet(I_D(0,3)) ), false );
BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(0,3)), ISet(I_D(0,1))+I_D(2,3) ), false );
- //[0 2)[2 4)
- // [1 4)
+ //[0 2)[2 4)
+ // [1 4)
BOOST_CHECK_EQUAL( is_element_equal( I_D(0,2)+ISet(I_D(2,4)), ISet(I_D(1,4)) ), false );
BOOST_CHECK_EQUAL( is_element_equal( ISet(I_D(1,4)), ISet(I_D(0,2))+I_D(2,4) ), false );
- //[0 2)[2 4)
- //[0 1)[1 3)[3 4)
+ //[0 2)[2 4)
+ //[0 1)[1 3)[3 4)
BOOST_CHECK_EQUAL( is_element_equal( I_D(0,2)+ISet(I_D(2,4)), I_D(0,1)+ISet(I_D(1,4))+I_D(3,4) ), true );
BOOST_CHECK_EQUAL( is_element_equal( I_D(0,1)+ISet(I_D(1,4))+I_D(3,4), I_D(0,2)+ISet(I_D(2,4)) ), true );
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -430,7 +430,7 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -474,7 +474,7 @@
// Test for nontrivial intersection of interval sets with intervals and values
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
@@ -548,167 +548,167 @@
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_flip_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- typedef IntervalSetT ISet;
+ typedef IntervalSet<T> IntervalSetT;
+ typedef IntervalSetT ISet;
- IntervalSetT set_a, set_b, lhs, rhs;
- //[0 2)
- // [1 3)
- //[0 1) [2 3) : {[0 2)} ^= [2 3)
- BOOST_CHECK_EQUAL(ISet(I_D(0,2)) ^= I_D(1,3), ISet(I_D(0,1)) + I_D(2,3));
-
- // [1 3)
- //[0 2)
- //[0 1) [2 3) : {[1 3)} ^= [0 2)
- BOOST_CHECK_EQUAL(ISet(I_D(1,3)) ^= I_D(0,2), ISet(I_D(0,1)) + I_D(2,3));
-
- //[0 2) (3 5]
- // [1 3)
- //[0 1) [2 3) (3 5] : a ^= b
- set_a.add(I_D(0,2)).add(C_I(3,5));
- set_b.add(I_D(1,3));
- lhs = set_a;
- lhs ^= set_b;
- rhs.add(I_D(0,1)).add(I_D(2,3)).add(C_I(3,5));
- BOOST_CHECK_EQUAL(lhs, rhs);
+ IntervalSetT set_a, set_b, lhs, rhs;
+ //[0 2)
+ // [1 3)
+ //[0 1) [2 3) : {[0 2)} ^= [2 3)
+ BOOST_CHECK_EQUAL(ISet(I_D(0,2)) ^= I_D(1,3), ISet(I_D(0,1)) + I_D(2,3));
+
+ // [1 3)
+ //[0 2)
+ //[0 1) [2 3) : {[1 3)} ^= [0 2)
+ BOOST_CHECK_EQUAL(ISet(I_D(1,3)) ^= I_D(0,2), ISet(I_D(0,1)) + I_D(2,3));
+
+ //[0 2) (3 5]
+ // [1 3)
+ //[0 1) [2 3) (3 5] : a ^= b
+ set_a.add(I_D(0,2)).add(C_I(3,5));
+ set_b.add(I_D(1,3));
+ lhs = set_a;
+ lhs ^= set_b;
+ rhs.add(I_D(0,1)).add(I_D(2,3)).add(C_I(3,5));
+ BOOST_CHECK_EQUAL(lhs, rhs);
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_infix_plus_overload_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef IntervalSet<T> IntervalSetT;
+ itl::interval<T> itv = I_D(3,5);
- IntervalSetT set_a, set_b;
- set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
- set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b;
+ set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
+ set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- BOOST_CHECK_EQUAL(set_a + set_b, set_b + set_a);
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(set_a + itv, itv + set_a);
- BOOST_CHECK_EQUAL(set_b + MK_v(4), MK_v(4) + set_b);
+ BOOST_CHECK_EQUAL(set_a + set_b, set_b + set_a);
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(set_a + itv, itv + set_a);
+ BOOST_CHECK_EQUAL(set_b + MK_v(4), MK_v(4) + set_b);
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_infix_pipe_overload_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef IntervalSet<T> IntervalSetT;
+ itl::interval<T> itv = I_D(3,5);
- IntervalSetT set_a, set_b;
- set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
- set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b;
+ set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
+ set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- BOOST_CHECK_EQUAL(set_a | set_b, set_b | set_a);
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(set_a | itv, itv | set_a);
- BOOST_CHECK_EQUAL(set_b | MK_v(4), MK_v(4) | set_b);
+ BOOST_CHECK_EQUAL(set_a | set_b, set_b | set_a);
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(set_a | itv, itv | set_a);
+ BOOST_CHECK_EQUAL(set_b | MK_v(4), MK_v(4) | set_b);
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_infix_minus_overload_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef IntervalSet<T> IntervalSetT;
+ itl::interval<T> itv = I_D(3,5);
- IntervalSetT set_a, set_b;
- set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
- set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b;
+ set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
+ set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- BOOST_CHECK_EQUAL(set_a - set_b, (set_b + set_a) - set_b);
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(set_a - itv, (itv + set_a) - itv);
- BOOST_CHECK_EQUAL(set_b - MK_v(4), (MK_v(4) + set_b) - MK_v(4));
+ BOOST_CHECK_EQUAL(set_a - set_b, (set_b + set_a) - set_b);
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(set_a - itv, (itv + set_a) - itv);
+ BOOST_CHECK_EQUAL(set_b - MK_v(4), (MK_v(4) + set_b) - MK_v(4));
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_infix_et_overload_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef IntervalSet<T> IntervalSetT;
+ itl::interval<T> itv = I_D(3,5);
- IntervalSetT set_a, set_b;
- set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
- set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b;
+ set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
+ set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- BOOST_CHECK_EQUAL(set_a & set_b, set_b & set_a);
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(set_a & itv, itv & set_a);
- BOOST_CHECK_EQUAL(set_b & MK_v(4), MK_v(4) & set_b);
+ BOOST_CHECK_EQUAL(set_a & set_b, set_b & set_a);
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(set_a & itv, itv & set_a);
+ BOOST_CHECK_EQUAL(set_b & MK_v(4), MK_v(4) & set_b);
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_infix_caret_overload_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef IntervalSet<T> IntervalSetT;
+ itl::interval<T> itv = I_D(3,5);
- IntervalSetT set_a, set_b;
- set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
- set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b;
+ set_a.add(C_D(1,3)).add(I_D(8,9)).add(I_I(6,11));
+ set_b.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- BOOST_CHECK_EQUAL(set_a ^ set_b, set_b ^ set_a);
- //This checks all cases of is_interval_set_derivative<T>
- BOOST_CHECK_EQUAL(set_a ^ itv, itv ^ set_a);
- BOOST_CHECK_EQUAL(set_b ^ MK_v(4), MK_v(4) ^ set_b);
+ BOOST_CHECK_EQUAL(set_a ^ set_b, set_b ^ set_a);
+ //This checks all cases of is_interval_set_derivative<T>
+ BOOST_CHECK_EQUAL(set_a ^ itv, itv ^ set_a);
+ BOOST_CHECK_EQUAL(set_b ^ MK_v(4), MK_v(4) ^ set_b);
}
template <template< class T,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- template<class,ITL_COMPARE>class Interval = interval,
+ template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalSet,
class T>
void interval_set_find_4_bicremental_types()
{
- typedef IntervalSet<T> IntervalSetT;
- itl::interval<T> itv = I_D(3,5);
+ typedef IntervalSet<T> IntervalSetT;
+ itl::interval<T> itv = I_D(3,5);
- IntervalSetT set_a;
- set_a.add(C_D(1,3)).add(I_I(6,11));
+ IntervalSetT set_a;
+ set_a.add(C_D(1,3)).add(I_I(6,11));
- IntervalSetT::const_iterator found = set_a.find(MK_v(6));
+ IntervalSetT::const_iterator found = set_a.find(MK_v(6));
- BOOST_CHECK_EQUAL( *found, I_I(6,11) );
+ BOOST_CHECK_EQUAL( *found, I_I(6,11) );
- found = set_a.find(MK_v(5));
+ found = set_a.find(MK_v(5));
- BOOST_CHECK_EQUAL( found == set_a.end(), true );
+ BOOST_CHECK_EQUAL( found == set_a.end(), true );
}
#endif // __test_itl_interval_set_shared_h_JOFA_080920__
Modified: sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval unit test
#include <string>
#include <boost/mpl/list.hpp>
@@ -169,11 +169,11 @@
T v7 = make<T>(7);
T v8 = make<T>(8);
BOOST_CHECK_EQUAL(interval<T>() < interval<T>(v7,v3), false);
- BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::rightopen(v7,v7), false);
- BOOST_CHECK_EQUAL(interval<T>::leftopen(v3,v3) < interval<T>::closed(v7,v3), false);
+ BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::rightopen(v7,v7), false);
+ BOOST_CHECK_EQUAL(interval<T>::leftopen(v3,v3) < interval<T>::closed(v7,v3), false);
BOOST_CHECK_EQUAL(interval<T>() < interval<T>(v3,v3), true);
- BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::rightopen(v7,v8), true);
+ BOOST_CHECK_EQUAL(interval<T>::open(v2,v3) < interval<T>::rightopen(v7,v8), true);
//I: (I)nside = closed bound
//C: left open bound
@@ -190,7 +190,7 @@
BOOST_CHECK_EQUAL( I3_7I < C2__7I , false);
BOOST_CHECK_EQUAL( I3_7I < C2___8D , false);
- BOOST_CHECK_EQUAL( I3_7I < I4_7I , true);
+ BOOST_CHECK_EQUAL( I3_7I < I4_7I , true);
BOOST_CHECK_EQUAL( I3__8D< I3__8D , false);
@@ -383,30 +383,30 @@
interval<T> I6_7D = interval<T>::rightopen(v6,v7);
interval<T> I2_4D = interval<T>::rightopen(v2,v4);
- I2_6D.right_subtract(diff_1,I4_7D);
+ I2_6D.right_subtract(diff_1,I4_7D);
BOOST_CHECK_EQUAL( diff_1, I2_4D );
- diff_2 = I2_6D;
- diff_2.right_subtract(I4_7D);
+ diff_2 = I2_6D;
+ diff_2.right_subtract(I4_7D);
BOOST_CHECK_EQUAL( diff_2, I2_4D );
- diff_1.clear();
- I0_3D.right_subtract(diff_1, I4_7D);
+ diff_1.clear();
+ I0_3D.right_subtract(diff_1, I4_7D);
BOOST_CHECK_EQUAL( diff_1, I0_3D );
-
- // ---------------------------------
- I4_7D.left_subtract(diff_1, I2_6D);
+
+ // ---------------------------------
+ I4_7D.left_subtract(diff_1, I2_6D);
BOOST_CHECK_EQUAL( diff_1, I6_7D );
- diff_2 = I4_7D;
- diff_2.left_subtract(I2_6D);
+ diff_2 = I4_7D;
+ diff_2.left_subtract(I2_6D);
BOOST_CHECK_EQUAL( diff_2, I6_7D );
- diff_1.clear();
- I4_7D.left_subtract(diff_1, I0_3D);
+ diff_1.clear();
+ I4_7D.left_subtract(diff_1, I0_3D);
BOOST_CHECK_EQUAL( diff_1, I4_7D );
- diff_2 = I4_7D;
- diff_2.left_subtract(I0_3D);
+ diff_2 = I4_7D;
+ diff_2.left_subtract(I0_3D);
BOOST_CHECK_EQUAL( diff_2, I4_7D );
}
Modified: sandbox/itl/libs/itl/test/test_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_itl_map_h_JOFA_090119__
#define __test_itl_itl_map_h_JOFA_090119__
@@ -25,23 +25,23 @@
void itl_map_find_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a;
- itv_map_a.add(IDv(2,4,1)).add(IIv(6,7,3));
+ IntervalMapT itv_map_a;
+ itv_map_a.add(IDv(2,4,1)).add(IIv(6,7,3));
- MapT map_a;
- Interval::atomize(map_a, itv_map_a);
+ MapT map_a;
+ Interval::atomize(map_a, itv_map_a);
- MapT::const_iterator found = map_a.find(MK_v(6));
+ MapT::const_iterator found = map_a.find(MK_v(6));
- BOOST_CHECK_EQUAL( found->CONT_VALUE, MK_u(3) );
- BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
+ BOOST_CHECK_EQUAL( found->CONT_VALUE, MK_u(3) );
+ BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
- found = map_a.find(MK_v(5));
+ found = map_a.find(MK_v(5));
- BOOST_CHECK_EQUAL( found == map_a.end(), true );
- BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
+ BOOST_CHECK_EQUAL( found == map_a.end(), true );
+ BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
}
#endif // __test_itl_itl_map_h_JOFA_090119__
Modified: sandbox/itl/libs/itl/test/test_itl_map/test_itl_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_map/test_itl_map.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_map/test_itl_map.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_itl_map/test_itl_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_map/test_itl_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_map/test_itl_map_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/libs/itl/test/test_laws.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_laws.hpp (original)
+++ sandbox/itl/libs/itl/test/test_laws.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_laws_h_JOFA_090119__
#define __test_itl_laws_h_JOFA_090119__
@@ -12,7 +12,7 @@
template<class Type>
struct equality : std::binary_function<Type,Type,bool>
{
- typedef bool (type)(const Type&, const Type&);
+ typedef bool (type)(const Type&, const Type&);
};
//------------------------------------------------------------------------------
@@ -23,9 +23,9 @@
template<class Type, class TypeB, class TypeC> \
void check_associativity_wrt_##op_tag(const Type& a, const TypeB& b, const TypeC& c) \
{ \
- Type left = (a op_sign b) op_sign c; \
- Type right = a op_sign (b op_sign c); \
- BOOST_CHECK_EQUAL(left,right); \
+ Type left = (a op_sign b) op_sign c; \
+ Type right = a op_sign (b op_sign c); \
+ BOOST_CHECK_EQUAL(left,right); \
}
#define DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
@@ -34,9 +34,9 @@
(typename equality<Type>::type* equal, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- Type left = (a op_sign b) op_sign c; \
- Type right = a op_sign (b op_sign c); \
- BOOST_CHECK_EQUAL((*equal)(left,right), true); \
+ Type left = (a op_sign b) op_sign c; \
+ Type right = a op_sign (b op_sign c); \
+ BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
#define CHECK_ASSOCIATIVITY_WRT(op_tag) check_associativity_wrt_##op_tag
@@ -61,9 +61,9 @@
void check_right_neutrality_wrt_equal_##op_tag \
(typename equality<Type>::type* equal, const Type& a, const Type& neutron) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron; \
- BOOST_CHECK_EQUAL((*equal)(left,right), true); \
+ Type left = a op_sign neutron; \
+ Type right = neutron; \
+ BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
#define DEFINE_RIGHT_NEUTRALITY_CHECK_WRT(op_tag, op_sign) \
@@ -71,9 +71,9 @@
void check_right_neutrality_wrt_##op_tag \
(typename equality<Type>::type* equal, const Type& a, const Type& neutron) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron; \
- BOOST_CHECK_EQUAL(left,right); \
+ Type left = a op_sign neutron; \
+ Type right = neutron; \
+ BOOST_CHECK_EQUAL(left,right); \
}
#define DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
@@ -81,9 +81,9 @@
void check_neutrality_wrt_equal_##op_tag \
(typename equality<Type>::type* equal, const Type& a, const Type& neutron) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron op_sign a; \
- BOOST_CHECK_EQUAL((*equal)(left,right), true); \
+ Type left = a op_sign neutron; \
+ Type right = neutron op_sign a; \
+ BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
#define DEFINE_NEUTRALITY_CHECK_WRT(op_tag, op_sign) \
@@ -91,9 +91,9 @@
void check_neutrality_wrt_##op_tag \
(const Type& a, const Type& neutron) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron op_sign a; \
- BOOST_CHECK_EQUAL(left,right); \
+ Type left = a op_sign neutron; \
+ Type right = neutron op_sign a; \
+ BOOST_CHECK_EQUAL(left,right); \
}
#define CHECK_NEUTRALITY_WRT(op_tag) check_neutrality_wrt_##op_tag
@@ -119,18 +119,18 @@
void check_commutativity_wrt_equal_##op_tag \
(typename equality<Type>::type* equal, const Type& a, const TypeB& b) \
{ \
- Type left = a op_sign b; \
- Type right = b op_sign a; \
- BOOST_CHECK_EQUAL((*equal)(left,right), true); \
+ Type left = a op_sign b; \
+ Type right = b op_sign a; \
+ BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
#define DEFINE_COMMUTATIVITY_CHECK_WRT(op_tag, op_sign) \
template<class Type, class TypeB> \
- void check_commutativity_wrt_##op_tag(const Type& a, const TypeB& b) \
+ void check_commutativity_wrt_##op_tag(const Type& a, const TypeB& b) \
{ \
- Type left = a op_sign b; \
- Type right = b op_sign a; \
- BOOST_CHECK_EQUAL(left,right); \
+ Type left = a op_sign b; \
+ Type right = b op_sign a; \
+ BOOST_CHECK_EQUAL(left,right); \
}
#define CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag) check_commutativity_wrt_equal_##op_tag
@@ -151,20 +151,20 @@
#define DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
template<class Type> \
- void check_partial_inversion_wrt_equal_##plus_tag \
+ void check_partial_inversion_wrt_equal_##plus_tag \
(typename equality<Type>::type* equal, const Type& neutron, const Type& var_a) \
{ \
- Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL((*equal)(positive_difference, neutron), true); \
+ Type positive_difference = var_a - var_a; \
+ BOOST_CHECK_EQUAL((*equal)(positive_difference, neutron), true); \
}
#define DEFINE_PARTIAL_INVERSION_CHECK_WRT(plus_tag, plus_sign) \
template<class Type> \
- void check_partial_inversion_wrt_##plus_tag \
+ void check_partial_inversion_wrt_##plus_tag \
(const Type& neutron, const Type& var_a) \
{ \
- Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL(positive_difference, neutron); \
+ Type positive_difference = var_a - var_a; \
+ BOOST_CHECK_EQUAL(positive_difference, neutron); \
}
#define CHECK_PARTIAL_INVERSION_WRT_EQUAL(plus_tag) check_partial_inversion_wrt_equal_##plus_tag
@@ -181,24 +181,24 @@
#define DEFINE_INVERSE_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
template<class Type> \
- void check_inverse_wrt_equal_##plus_tag \
+ void check_inverse_wrt_equal_##plus_tag \
(typename equality<Type>::type* equal, const Type& neutron, const Type& var_a) \
{ \
- Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL((*equal)(positive_difference, neutron), true); \
- Type negative_difference = (neutron - var_a) plus_sign var_a; \
- BOOST_CHECK_EQUAL((*equal)(negative_difference, neutron), true); \
+ Type positive_difference = var_a - var_a; \
+ BOOST_CHECK_EQUAL((*equal)(positive_difference, neutron), true); \
+ Type negative_difference = (neutron - var_a) plus_sign var_a; \
+ BOOST_CHECK_EQUAL((*equal)(negative_difference, neutron), true); \
}
#define DEFINE_INVERSE_CHECK_WRT(plus_tag, plus_sign) \
template<class Type> \
- void check_inverse_wrt_##plus_tag \
+ void check_inverse_wrt_##plus_tag \
(const Type& neutron, const Type& var_a) \
{ \
- Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL(positive_difference, neutron); \
- Type negative_difference = (neutron - var_a) plus_sign var_a; \
- BOOST_CHECK_EQUAL(negative_difference, neutron); \
+ Type positive_difference = var_a - var_a; \
+ BOOST_CHECK_EQUAL(positive_difference, neutron); \
+ Type negative_difference = (neutron - var_a) plus_sign var_a; \
+ BOOST_CHECK_EQUAL(negative_difference, neutron); \
}
#define CHECK_INVERSE_WRT_EQUAL(plus_tag) check_inverse_wrt_equal_##plus_tag
@@ -219,8 +219,8 @@
(typename equality<Type>::type* equal, const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
- CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,neutron); \
+ CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
+ CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,neutron); \
}
#define DEFINE_MONOID_CHECK_WRT(op_tag) \
@@ -229,8 +229,8 @@
(typename const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
- CHECK_NEUTRALITY_WRT(op_tag)(a,neutron); \
+ CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
+ CHECK_NEUTRALITY_WRT(op_tag)(a,neutron); \
}
DEFINE_MONOID_CHECK_WRT(plus);
@@ -254,10 +254,10 @@
(typename equality<Type>::type* equal, const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
- CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,neutron); \
- CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,b); \
- CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,c); \
+ CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
+ CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,neutron); \
+ CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,b); \
+ CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,c); \
}
#define DEFINE_ABELIAN_MONOID_CHECK_WRT(op_tag) \
@@ -266,10 +266,10 @@
(typename const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
- CHECK_NEUTRALITY_WRT(op_tag)(a,neutron); \
- CHECK_COMMUTATIVITY_WRT(op_tag)(a,b); \
- CHECK_COMMUTATIVITY_WRT(op_tag)(a,c); \
+ CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
+ CHECK_NEUTRALITY_WRT(op_tag)(a,neutron); \
+ CHECK_COMMUTATIVITY_WRT(op_tag)(a,b); \
+ CHECK_COMMUTATIVITY_WRT(op_tag)(a,c); \
}
DEFINE_ABELIAN_MONOID_CHECK_WRT(plus);
@@ -293,8 +293,8 @@
(typename equality<Type>::type* equal, const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,neutron,a,b,c); \
- CHECK_PARTIAL_INVERSION_WRT_EQUAL(op_tag)(equal,neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,neutron,a,b,c); \
+ CHECK_PARTIAL_INVERSION_WRT_EQUAL(op_tag)(equal,neutron,a); \
}
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(op_tag) \
@@ -303,8 +303,8 @@
(typename const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron,a,b,c); \
- CHECK_PARTIAL_INVERSION_WRT(op_tag)(neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron,a,b,c); \
+ CHECK_PARTIAL_INVERSION_WRT(op_tag)(neutron,a); \
}
DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(plus);
@@ -325,22 +325,22 @@
#define DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(op_tag) \
template<class Type, class TypeB, class TypeC> \
- void check_abelian_group_wrt_equal_##op_tag \
+ void check_abelian_group_wrt_equal_##op_tag \
(typename equality<Type>::type* equal, const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,neutron,a,b,c); \
- CHECK_INVERSE_WRT_EQUAL(op_tag)(equal,neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,neutron,a,b,c); \
+ CHECK_INVERSE_WRT_EQUAL(op_tag)(equal,neutron,a); \
}
#define DEFINE_ABELIAN_GROUP_CHECK_WRT(op_tag) \
template<class Type, class TypeB, class TypeC> \
- void check_abelian_group_wrt_##op_tag \
+ void check_abelian_group_wrt_##op_tag \
(const Type& neutron, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron,a,b,c); \
- CHECK_INVERSE_WRT(op_tag)(neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron,a,b,c); \
+ CHECK_INVERSE_WRT(op_tag)(neutron,a); \
}
@@ -361,10 +361,10 @@
void check_monoid_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -372,10 +372,10 @@
void check_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -401,10 +401,10 @@
void check_abelian_monoid_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -412,10 +412,10 @@
void check_abelian_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -441,10 +441,10 @@
void check_partial_invertive_monoid_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -452,10 +452,10 @@
void check_partial_invertive_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -478,24 +478,24 @@
#define DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(op_tag) \
template<class TypeA, class TypeB, class Assoc> \
- void check_abelian_group_permuted_wrt_equal_##op_tag \
+ void check_abelian_group_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, neutron<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(op_tag) \
template<class TypeA, class TypeB, class Assoc> \
- void check_abelian_group_permuted_wrt_##op_tag \
+ void check_abelian_group_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(neutron<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -518,9 +518,9 @@
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
- CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
- CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
+ CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
+ CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
+ CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
}
#define DEFINE_MONOID_CHECK_INSTANCE_WRT(op_tag) \
@@ -529,9 +529,9 @@
(const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
- CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
- CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
+ CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
+ CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
+ CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}
DEFINE_MONOID_CHECK_INSTANCE_WRT(plus);
@@ -558,9 +558,9 @@
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
- CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
- CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
+ CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
+ CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
+ CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
}
#define DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(op_tag) \
@@ -569,9 +569,9 @@
(const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
- CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
- CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
+ CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
+ CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
+ CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}
DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(plus);
@@ -597,9 +597,9 @@
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
- CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
- CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
}
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(op_tag) \
@@ -608,9 +608,9 @@
(const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
- CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
- CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}
DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(plus);
@@ -632,24 +632,24 @@
#define DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(op_tag) \
template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
- void check_abelian_group_instance_wrt_equal_##op_tag \
+ void check_abelian_group_instance_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
- CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
- CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
+ CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
+ CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
+ CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
}
#define DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(op_tag) \
template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
- void check_abelian_group_instance_wrt_##op_tag \
+ void check_abelian_group_instance_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
const AssocA& ass_a, const AssocB& ass_b) \
{ \
- CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
- CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
- CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
+ CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
+ CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
+ CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
}
DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(plus);
Modified: sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_quantifier_itl_map_h_JOFA_090119__
#define __test_itl_quantifier_itl_map_h_JOFA_090119__
@@ -25,23 +25,23 @@
void quantifier_map_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
}
@@ -58,23 +58,23 @@
void quantifier_map_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, map_pair1, map_pair2);
}
//------------------------------------------------------------------------------
@@ -94,23 +94,23 @@
void quantifier_map_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
}
@@ -127,23 +127,23 @@
void quantifier_map_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, map_pair1, map_pair2);
}
@@ -163,23 +163,23 @@
void quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
}
//------------------------------------------------------------------------------
@@ -198,26 +198,26 @@
void quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
}
@@ -237,23 +237,23 @@
void quantifier_map_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
}
//------------------------------------------------------------------------------
@@ -272,26 +272,26 @@
void quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef itl::map<T,U,Trt> MapT;
- IntervalMapT itv_map_a, itv_map_b, itv_map_c;
- itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- MapT map_a, map_b, map_c;
- Interval::atomize(map_a, itv_map_a);
- Interval::atomize(map_b, itv_map_b);
- Interval::atomize(map_c, itv_map_c);
+ IntervalMapT itv_map_a, itv_map_b, itv_map_c;
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ MapT map_a, map_b, map_c;
+ Interval::atomize(map_a, itv_map_a);
+ Interval::atomize(map_b, itv_map_b);
+ Interval::atomize(map_c, itv_map_c);
- MapT::value_type map_pair1 = sK_v(5,1);
- MapT::value_type map_pair2 = sK_v(9,3);
+ MapT::value_type map_pair1 = sK_v(5,1);
+ MapT::value_type map_pair2 = sK_v(9,3);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
}
#endif // __test_itl_quantifier_itl_map_h_JOFA_090119__
Modified: sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map.cpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_itl_map/test_quantifier_itl_map_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map.cpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
+Copyright (c) 2008-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
Modified: sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_quantifier_map_shared_h_JOFA_090119__
#define __test_itl_quantifier_map_shared_h_JOFA_090119__
@@ -26,16 +26,16 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
}
@@ -53,16 +53,16 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, val_pair, map_pair);
}
//------------------------------------------------------------------------------
@@ -83,16 +83,16 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
}
@@ -110,16 +110,16 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, val_pair, map_pair);
}
@@ -140,16 +140,16 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
}
//------------------------------------------------------------------------------
@@ -169,19 +169,19 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
}
@@ -202,16 +202,16 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
}
//------------------------------------------------------------------------------
@@ -231,19 +231,19 @@
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+ IntervalMapT map_a, map_b, map_c;
+ map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
+ mapping_pair<T,U> map_pair = K_v(5,1);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
}
Modified: sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_separate_interval_set/test_separate_interval_set_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_interval_set_fundamentals_4_ordered_types, T, ordered_types)
Modified: sandbox/itl/libs/itl/test/test_set_inerval_set/test_set_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_inerval_set/test_set_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/test_set_inerval_set/test_set_interval_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_set_interval_set_h_JOFA_090119__
#define __test_itl_set_interval_set_h_JOFA_090119__
@@ -23,16 +23,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
- typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
+ typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
+ typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
- CHECK_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, inter_val1, inter_val2);
- CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
}
template <class T,
@@ -49,16 +49,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
- typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
+ typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
+ typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
- CHECK_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, inter_val1, inter_val2);
- CHECK_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, inter_val1, inter_val2);
}
//------------------------------------------------------------------------------
@@ -76,16 +76,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
- typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
+ typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
+ typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, inter_val1, inter_val2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
}
template <class T,
@@ -99,16 +99,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
- typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
+ typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
+ typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, inter_val1, inter_val2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, inter_val1, inter_val2);
}
@@ -126,16 +126,16 @@
{
typedef IntervalSet<T> IntervalSetT;
- IntervalSetT set_a, set_b, set_c;
- set_a.add(I_D(3,6)).add(I_I(5,7));
- set_b.add(C_D(1,3)).add(I_D(8,9));
- set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+ IntervalSetT set_a, set_b, set_c;
+ set_a.add(I_D(3,6)).add(I_I(5,7));
+ set_b.add(C_D(1,3)).add(I_D(8,9));
+ set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
- typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
- typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
+ typename IntervalSetT::segment_type inter_val1 = I_D(6,9);
+ typename IntervalSetT::segment_type inter_val2 = I_I(5,5);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, inter_val1, inter_val2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, inter_val1, inter_val2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, inter_val1, inter_val2);
}
Modified: sandbox/itl/libs/itl/test/test_set_itl_set.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_itl_set.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_itl_set.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __test_itl_set_itl_set_h_JOFA_090119__
#define __test_itl_set_itl_set_h_JOFA_090119__
@@ -22,23 +22,23 @@
void itl_set_check_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- typedef itl::set<T> SetT;
+ typedef itl::set<T> SetT;
- IntervalSetT itv_set_a, itv_set_b, itv_set_c;
- itv_set_a.add(I_D(3,6)).add(I_I(5,7));
- itv_set_b.add(C_D(1,3)).add(I_D(8,9));
- itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
-
- SetT set_a, set_b, set_c;
- Interval::atomize(set_a, itv_set_a);
- Interval::atomize(set_b, itv_set_b);
- Interval::atomize(set_c, itv_set_c);
+ IntervalSetT itv_set_a, itv_set_b, itv_set_c;
+ itv_set_a.add(I_D(3,6)).add(I_I(5,7));
+ itv_set_b.add(C_D(1,3)).add(I_D(8,9));
+ itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+
+ SetT set_a, set_b, set_c;
+ Interval::atomize(set_a, itv_set_a);
+ Interval::atomize(set_b, itv_set_b);
+ Interval::atomize(set_c, itv_set_c);
- T val1 = MK_v(7);
- T val2 = MK_v(5);
+ T val1 = MK_v(7);
+ T val2 = MK_v(5);
- CHECK_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, val1, val2);
- CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
+ CHECK_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, val1, val2);
+ CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}
@@ -55,23 +55,23 @@
void itl_set_check_monoid_et_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- typedef itl::set<T> SetT;
+ typedef itl::set<T> SetT;
- IntervalSetT itv_set_a, itv_set_b, itv_set_c;
- itv_set_a.add(I_D(3,6)).add(I_I(5,7));
- itv_set_b.add(C_D(1,3)).add(I_D(8,9));
- itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
-
- SetT set_a, set_b, set_c;
- Interval::atomize(set_a, itv_set_a);
- Interval::atomize(set_b, itv_set_b);
- Interval::atomize(set_c, itv_set_c);
+ IntervalSetT itv_set_a, itv_set_b, itv_set_c;
+ itv_set_a.add(I_D(3,6)).add(I_I(5,7));
+ itv_set_b.add(C_D(1,3)).add(I_D(8,9));
+ itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+
+ SetT set_a, set_b, set_c;
+ Interval::atomize(set_a, itv_set_a);
+ Interval::atomize(set_b, itv_set_b);
+ Interval::atomize(set_c, itv_set_c);
- T val1 = MK_v(7);
- T val2 = MK_v(5);
+ T val1 = MK_v(7);
+ T val2 = MK_v(5);
- CHECK_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, val1, val2);
- CHECK_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, val1, val2);
+ CHECK_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, val1, val2);
+ CHECK_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, val1, val2);
}
//------------------------------------------------------------------------------
@@ -88,23 +88,23 @@
void itl_set_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- typedef itl::set<T> SetT;
+ typedef itl::set<T> SetT;
- IntervalSetT itv_set_a, itv_set_b, itv_set_c;
- itv_set_a.add(I_D(3,6)).add(I_I(5,7));
- itv_set_b.add(C_D(1,3)).add(I_D(8,9));
- itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
-
- SetT set_a, set_b, set_c;
- Interval::atomize(set_a, itv_set_a);
- Interval::atomize(set_b, itv_set_b);
- Interval::atomize(set_c, itv_set_c);
+ IntervalSetT itv_set_a, itv_set_b, itv_set_c;
+ itv_set_a.add(I_D(3,6)).add(I_I(5,7));
+ itv_set_b.add(C_D(1,3)).add(I_D(8,9));
+ itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+
+ SetT set_a, set_b, set_c;
+ Interval::atomize(set_a, itv_set_a);
+ Interval::atomize(set_b, itv_set_b);
+ Interval::atomize(set_c, itv_set_c);
- T val1 = MK_v(7);
- T val2 = MK_v(5);
+ T val1 = MK_v(7);
+ T val2 = MK_v(5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, val1, val2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, val1, val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}
template <class T,
@@ -117,23 +117,23 @@
void itl_set_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- typedef itl::set<T> SetT;
+ typedef itl::set<T> SetT;
- IntervalSetT itv_set_a, itv_set_b, itv_set_c;
- itv_set_a.add(I_D(3,6)).add(I_I(5,7));
- itv_set_b.add(C_D(1,3)).add(I_D(8,9));
- itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
-
- SetT set_a, set_b, set_c;
- Interval::atomize(set_a, itv_set_a);
- Interval::atomize(set_b, itv_set_b);
- Interval::atomize(set_c, itv_set_c);
+ IntervalSetT itv_set_a, itv_set_b, itv_set_c;
+ itv_set_a.add(I_D(3,6)).add(I_I(5,7));
+ itv_set_b.add(C_D(1,3)).add(I_D(8,9));
+ itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+
+ SetT set_a, set_b, set_c;
+ Interval::atomize(set_a, itv_set_a);
+ Interval::atomize(set_b, itv_set_b);
+ Interval::atomize(set_c, itv_set_c);
- T val1 = MK_v(7);
- T val2 = MK_v(5);
+ T val1 = MK_v(7);
+ T val2 = MK_v(5);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, val1, val2);
- CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, val1, val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (set_a, set_b, set_c, val1, val2);
+ CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(set_a, set_b, set_c, val1, val2);
}
@@ -150,23 +150,23 @@
void itl_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
- typedef itl::set<T> SetT;
+ typedef itl::set<T> SetT;
- IntervalSetT itv_set_a, itv_set_b, itv_set_c;
- itv_set_a.add(I_D(3,6)).add(I_I(5,7));
- itv_set_b.add(C_D(1,3)).add(I_D(8,9));
- itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
-
- SetT set_a, set_b, set_c;
- Interval::atomize(set_a, itv_set_a);
- Interval::atomize(set_b, itv_set_b);
- Interval::atomize(set_c, itv_set_c);
+ IntervalSetT itv_set_a, itv_set_b, itv_set_c;
+ itv_set_a.add(I_D(3,6)).add(I_I(5,7));
+ itv_set_b.add(C_D(1,3)).add(I_D(8,9));
+ itv_set_c.add(I_D(0,9)).add(I_I(3,6)).add(I_D(5,7));
+
+ SetT set_a, set_b, set_c;
+ Interval::atomize(set_a, itv_set_a);
+ Interval::atomize(set_b, itv_set_b);
+ Interval::atomize(set_c, itv_set_c);
- T val1 = MK_v(7);
- T val2 = MK_v(5);
+ T val1 = MK_v(7);
+ T val2 = MK_v(5);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, val1, val2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, val1, val2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}
Modified: sandbox/itl/libs/itl/test/test_set_itl_set/test_set_itl_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_itl_set/test_set_itl_set.cpp (original)
+++ sandbox/itl/libs/itl/test/test_set_itl_set/test_set_itl_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map.cpp (original)
+++ sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::split_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_split_interval_map/test_split_interval_map_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_interval_map_fundamentals_4_ordered_types, T, ordered_types)
Modified: sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#define BOOST_TEST_MODULE itl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
Modified: sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_split_interval_set/test_split_interval_set_shared.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_interval_set_fundamentals_4_ordered_types, T, ordered_types)
Modified: sandbox/itl/libs/itl/test/test_type_lists.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_type_lists.hpp (original)
+++ sandbox/itl/libs/itl/test/test_type_lists.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_test_type_lists_JOFA_080916_H__
#define __itl_test_type_lists_JOFA_080916_H__
Modified: sandbox/itl/libs/itl/test/test_value_maker.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_value_maker.hpp (original)
+++ sandbox/itl/libs/itl/test/test_value_maker.hpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,10 +1,10 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#ifndef __itl_test_value_maker_JOFA_080916_H__
#define __itl_test_value_maker_JOFA_080916_H__
@@ -16,10 +16,10 @@
/*JODO completion like that:
std::string make(int n)
{
- std::string value = neutron<std::string>::value();
- int abs_n = n<0 ? -n : n;
- for(int i=1; i<abs_n; i++)
- value += i%2==1 ? "hello " : "world ";
+ std::string value = neutron<std::string>::value();
+ int abs_n = n<0 ? -n : n;
+ for(int i=1; i<abs_n; i++)
+ value += i%2==1 ? "hello " : "world ";
}
*/
@@ -44,68 +44,68 @@
template<>
struct test_value<std::string>
{
- static std::string make(int n)
- {
- std::string value = neutron<std::string>::value();
- int abs_n = n<0 ? -n : n;
- for(int i=1; i<abs_n; i++)
- value += (i%2==1 ? "hello " : "world ");
-
- return value;
- }
+ static std::string make(int n)
+ {
+ std::string value = neutron<std::string>::value();
+ int abs_n = n<0 ? -n : n;
+ for(int i=1; i<abs_n; i++)
+ value += (i%2==1 ? "hello " : "world ");
+
+ return value;
+ }
};
template <class Type>
struct test_value
{
- static Type make(int n)
- {
- Type value = neutron<Type>::value();
- if(n>=0)
- for(int i=0; i<n; i++)
- ++value;
- else
- for(int i=0; i>n; i--)
- --value;
+ static Type make(int n)
+ {
+ Type value = neutron<Type>::value();
+ if(n>=0)
+ for(int i=0; i<n; i++)
+ ++value;
+ else
+ for(int i=0; i>n; i--)
+ --value;
- return value;
- }
+ return value;
+ }
};
template <class ItvMapT>
struct map_val
{
- typedef typename ItvMapT::domain_type domain_type;
- typedef typename ItvMapT::codomain_type codomain_type;
- typedef typename ItvMapT::interval_type interval_type;
- typedef typename ItvMapT::value_type value_type;
- typedef typename ItvMapT::domain_mapping_type domain_mapping_type;
- typedef std::pair<domain_type, codomain_type> std_pair_type;
-
- static interval<domain_type> interval(int lower, int upper, int bounds = 2)
- {
- return interval_type(test_value<domain_type>::make(lower),
- test_value<domain_type>::make(upper), bounds);
- }
-
- static value_type val_pair(int lower, int upper, int val, int bounds = 2)
- {
- return value_type( interval(lower, upper, bounds),
- test_value<codomain_type>::make(val) );
- }
-
- static domain_mapping_type map_pair(int key, int val)
- {
- return domain_mapping_type(test_value< domain_type>::make(key),
- test_value<codomain_type>::make(val));
- }
-
- static std_pair_type std_pair(int key, int val)
- {
- return std_pair_type(test_value< domain_type>::make(key),
- test_value<codomain_type>::make(val));
- }
+ typedef typename ItvMapT::domain_type domain_type;
+ typedef typename ItvMapT::codomain_type codomain_type;
+ typedef typename ItvMapT::interval_type interval_type;
+ typedef typename ItvMapT::value_type value_type;
+ typedef typename ItvMapT::domain_mapping_type domain_mapping_type;
+ typedef std::pair<domain_type, codomain_type> std_pair_type;
+
+ static interval<domain_type> interval(int lower, int upper, int bounds = 2)
+ {
+ return interval_type(test_value<domain_type>::make(lower),
+ test_value<domain_type>::make(upper), bounds);
+ }
+
+ static value_type val_pair(int lower, int upper, int val, int bounds = 2)
+ {
+ return value_type( interval(lower, upper, bounds),
+ test_value<codomain_type>::make(val) );
+ }
+
+ static domain_mapping_type map_pair(int key, int val)
+ {
+ return domain_mapping_type(test_value< domain_type>::make(key),
+ test_value<codomain_type>::make(val));
+ }
+
+ static std_pair_type std_pair(int key, int val)
+ {
+ return std_pair_type(test_value< domain_type>::make(key),
+ test_value<codomain_type>::make(val));
+ }
};
// Very short value denotation for intervals
Modified: sandbox/itl/libs/itl_xt/example/amount_cube/amount_cube.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/example/amount_cube/amount_cube.cpp (original)
+++ sandbox/itl/libs/itl_xt/example/amount_cube/amount_cube.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <stdio.h>
#include <iostream>
Modified: sandbox/itl/libs/itl_xt/example/history/history.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/example/history/history.cpp (original)
+++ sandbox/itl/libs/itl_xt/example/history/history.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,13 +1,13 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
+Copyright (c) 2007-2009: 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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <stdio.h>
#include <iostream>
#include <boost/itl/type_traits/to_string.hpp>
@@ -157,7 +157,7 @@
class DiagnosisEpisode : public HospitalEpisodes
{
public:
- DiagnosisEpisode(Time begin, Time end, const std::string& val)
+ DiagnosisEpisode(Time begin, Time end, const std::string& val)
: HospitalEpisodes(boost::itl::interval<Time>::rightopen(begin,end),val){}
HospitalTypeDomain::DomainET type()const { return HospitalTypeDomain::diagnosis; }
Modified: sandbox/itl/libs/itl_xt/example/toytime.h
==============================================================================
--- sandbox/itl/libs/itl_xt/example/toytime.h (original)
+++ sandbox/itl/libs/itl_xt/example/toytime.h 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
namespace boost{namespace itl
{
Modified: sandbox/itl/libs/itl_xt/test/auto_itv_test/auto_itv_test.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/test/auto_itv_test/auto_itv_test.cpp (original)
+++ sandbox/itl/libs/itl_xt/test/auto_itv_test/auto_itv_test.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,7 +1,7 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2007-2008: Joachim Faulhaber
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -25,9 +25,9 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
auto_itv_test.cpp provides automated tests:
A geneator generates instances of interval container. For each instance
properties are checked, e. g. symmetric difference on ItvSets:
@@ -38,7 +38,7 @@
The test procedures allow for specifying the number of tests to be performed
and the maximum size of generated interval containers. The error file collects
information on the erroneous testcases if there are any.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <boost/itl/split_interval_set.hpp>
Modified: sandbox/itl/libs/itl_xt/test/itvsettester.h
==============================================================================
--- sandbox/itl/libs/itl_xt/test/itvsettester.h (original)
+++ sandbox/itl/libs/itl_xt/test/itvsettester.h 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
class ItvSetTesterT
Modified: sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp (original)
+++ sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,6 +1,6 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
@@ -24,7 +24,7 @@
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <set>
@@ -82,25 +82,25 @@
class PairSet1
{
public:
- typedef std::set
- <
- std::pair<T1,T1>,
- typename mpl::apply<Compare, std::pair<T1,T1> >::type
- >
- ImplSetT;
-
- typedef std::set
- <
- T1,
- typename mpl::apply<Compare, T1>::type
- >
- ElemSetT;
- //
- PairSet1(): _set()
- {cout << "PairSet1 constructed" << endl;}
+ typedef std::set
+ <
+ std::pair<T1,T1>,
+ typename mpl::apply<Compare, std::pair<T1,T1> >::type
+ >
+ ImplSetT;
+
+ typedef std::set
+ <
+ T1,
+ typename mpl::apply<Compare, T1>::type
+ >
+ ElemSetT;
+ //
+ PairSet1(): _set()
+ {cout << "PairSet1 constructed" << endl;}
private:
- ElemSetT _set;
+ ElemSetT _set;
};
typedef PairSet1<int, std::less<_> > PairSet1_int;
@@ -111,16 +111,16 @@
class my_class
{
public:
- typedef Vec<T,A> vec_type;
- my_class():_vec(1,static_cast<T>(42))
- { std::cout<<"Aswer: "<<_vec[0]<<endl; }
+ typedef Vec<T,A> vec_type;
+ my_class():_vec(1,static_cast<T>(42))
+ { std::cout<<"Aswer: "<<_vec[0]<<endl; }
private:
- vec_type _vec;
+ vec_type _vec;
};
void template_default_problem()
{
- my_class<double, std::vector> myInst;
+ my_class<double, std::vector> myInst;
}
/*
@@ -131,10 +131,10 @@
{
public:
typedef
- set<interval<T>,
+ set<interval<T>,
exclusive_less<interval<T> >
- A::allocator_template<interval<T> >//error
- > impl_type; // ^^^^ No language support
+ A::allocator_template<interval<T> >//error
+ > impl_type; // ^^^^ No language support
typedef set<T,C,A> atomized_type;
@@ -151,10 +151,10 @@
{
public:
typedef
- set<interval<T>,
+ set<interval<T>,
exclusive_less<interval<T> >
- A<interval<T> > //ok now
- > impl_type;
+ A<interval<T> > //ok now
+ > impl_type;
typedef
set<T,C,
@@ -169,24 +169,24 @@
class NoPlus
{
- //NoPlus(const NoPlus& val):_value(val._value){}
+ //NoPlus(const NoPlus& val):_value(val._value){}
public:
- NoPlus():_value(0){}
- NoPlus(int value):_value(value){}
+ NoPlus():_value(0){}
+ NoPlus(int value):_value(value){}
- bool operator < (const NoPlus& rhs)const
- { return _value < rhs._value; }
+ bool operator < (const NoPlus& rhs)const
+ { return _value < rhs._value; }
- bool operator == (const NoPlus& rhs)const
- { return _value == rhs._value; }
+ bool operator == (const NoPlus& rhs)const
+ { return _value == rhs._value; }
- int value()const { return _value; }
+ int value()const { return _value; }
- std::string as_string()const
- { return to_string<int>::apply(_value); }
+ std::string as_string()const
+ { return to_string<int>::apply(_value); }
private:
- int _value;
+ int _value;
};
template<class CharType, class CharTraits>
@@ -194,71 +194,71 @@
(std::basic_ostream<CharType, CharTraits>& stream,
const NoPlus& object)
{
- return stream << object.value();
+ return stream << object.value();
}
void codomain_test()
{
- typedef split_interval_map<int,NoPlus> NoplumT;
- NoplumT noplum;
- //noplum.insert(mapping_pair<int,NoPlus>(47,NoPlus(11)));
- //noplum.insert(mapping_pair<int,NoPlus>(42,NoPlus(14)));
- //noplum.erase(mapping_pair<int,NoPlus>(42,NoPlus(14)));
-
- noplum.insert(make_pair(interval<int>::rightopen(2,6),NoPlus(1)));
- noplum.insert(make_pair(interval<int>::rightopen(4,8),NoPlus(2)));
+ typedef split_interval_map<int,NoPlus> NoplumT;
+ NoplumT noplum;
+ //noplum.insert(mapping_pair<int,NoPlus>(47,NoPlus(11)));
+ //noplum.insert(mapping_pair<int,NoPlus>(42,NoPlus(14)));
+ //noplum.erase(mapping_pair<int,NoPlus>(42,NoPlus(14)));
+
+ noplum.insert(make_pair(interval<int>::rightopen(2,6),NoPlus(1)));
+ noplum.insert(make_pair(interval<int>::rightopen(4,8),NoPlus(2)));
- cout << noplum << endl;
+ cout << noplum << endl;
}
void string_codomain_test()
{
- typedef interval_map<int,std::string> ConcaMapT;
- ConcaMapT cat_map;
- cat_map += make_pair(interval<int>::rightopen(1,5),std::string("Hello"));
- cat_map += make_pair(interval<int>::rightopen(3,7),std::string(" World"));
-
- cout << "cat_map: " << cat_map << endl;
+ typedef interval_map<int,std::string> ConcaMapT;
+ ConcaMapT cat_map;
+ cat_map += make_pair(interval<int>::rightopen(1,5),std::string("Hello"));
+ cat_map += make_pair(interval<int>::rightopen(3,7),std::string(" World"));
+
+ cout << "cat_map: " << cat_map << endl;
}
void quantifier_intersect_test()
{
- typedef interval_map<int,int> QuantifierT;
- QuantifierT sec_map;
- sec_map += make_pair(interval<int>::rightopen(1,5), 1);
- sec_map &= make_pair(interval<int>::rightopen(3,7), 1);
- //sec_map &= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
-
- cout << "sec_map: " << sec_map << endl;
+ typedef interval_map<int,int> QuantifierT;
+ QuantifierT sec_map;
+ sec_map += make_pair(interval<int>::rightopen(1,5), 1);
+ sec_map &= make_pair(interval<int>::rightopen(3,7), 1);
+ //sec_map &= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
+
+ cout << "sec_map: " << sec_map << endl;
}
void quantifier_subtract_test()
{
- typedef interval_map<int,nat> QuantifierT;
- QuantifierT sec_map;
- sec_map += QuantifierT::value_type(interval<int>::rightopen(1,5), 1);
- sec_map -= make_pair(interval<int>::rightopen(3,7), static_cast<nat>(2));
- sec_map += make_pair(interval<int>::rightopen(3,7), static_cast<nat>(3));
- //sec_map *= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
-
- QuantifierT sec_map2;
+ typedef interval_map<int,nat> QuantifierT;
+ QuantifierT sec_map;
+ sec_map += QuantifierT::value_type(interval<int>::rightopen(1,5), 1);
+ sec_map -= make_pair(interval<int>::rightopen(3,7), static_cast<nat>(2));
+ sec_map += make_pair(interval<int>::rightopen(3,7), static_cast<nat>(3));
+ //sec_map *= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
+
+ QuantifierT sec_map2;
- if(sec_map != sec_map2)
- cout << "geht doch\n";
+ if(sec_map != sec_map2)
+ cout << "geht doch\n";
- cout << "sec_map: " << sec_map << endl;
+ cout << "sec_map: " << sec_map << endl;
}
void misc_test()
{
- typedef interval_map<int,int,partial_enricher> MapT;
- MapT m;
- m += MapT::value_type(interval<int>::rightopen(1,3), 1);
- cout << m << endl;
- m -= MapT::value_type(interval<int>::rightopen(1,3), 1);
- cout << m << endl;
+ typedef interval_map<int,int,partial_enricher> MapT;
+ MapT m;
+ m += MapT::value_type(interval<int>::rightopen(1,3), 1);
+ cout << m << endl;
+ m -= MapT::value_type(interval<int>::rightopen(1,3), 1);
+ cout << m << endl;
}
int main()
@@ -266,20 +266,20 @@
cout << ">> Interval Template Library: Test meta_functors <<\n";
cout << "-------------------------------------------------------\n";
- /*
- unator1<int, unary> untor1; untor1.speak();
- unator2<int, unary<_> > untor2; untor2.speak();
- binator1<int, int, binary> bintor1; bintor1.speak();
- binator2<int, int, binary<_1,_2> > bintor2; bintor2.speak();
-
- PairSet1_int ps1;
-
- template_default_problem();
- */
- //codomain_test();
- //string_codomain_test();
- //quantifier_subtract_test();
- misc_test();
+ /*
+ unator1<int, unary> untor1; untor1.speak();
+ unator2<int, unary<_> > untor2; untor2.speak();
+ binator1<int, int, binary> bintor1; bintor1.speak();
+ binator2<int, int, binary<_1,_2> > bintor2; bintor2.speak();
+
+ PairSet1_int ps1;
+
+ template_default_problem();
+ */
+ //codomain_test();
+ //string_codomain_test();
+ //quantifier_subtract_test();
+ misc_test();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_collector/labat_collector.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_collector/labat_collector.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_collector/labat_collector.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
#include <boost/validate/driver/collector_driver.hpp>
@@ -30,6 +30,6 @@
int main()
{
- test_collector_driver();
+ test_collector_driver();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_itl_morphic/labat_itl_morphic.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itl_morphic/labat_itl_morphic.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itl_morphic/labat_itl_morphic.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -31,6 +31,6 @@
int main()
{
- test_itl_morphic_driver();
+ test_itl_morphic_driver();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_itl_order/labat_itl_order.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itl_order/labat_itl_order.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itl_order/labat_itl_order.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -42,6 +42,6 @@
int main()
{
- test_itl_order_driver();
+ test_itl_order_driver();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_itl_set/labat_itl_set.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itl_set/labat_itl_set.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itl_set/labat_itl_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -31,6 +31,6 @@
int main()
{
- test_itl_set_driver();
+ test_itl_set_driver();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_itv_map_groupig/labat_itv_map_groupig.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itv_map_groupig/labat_itv_map_groupig.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itv_map_groupig/labat_itv_map_groupig.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -47,6 +47,6 @@
int main()
{
- test_ItvMapGroupigValidater();
+ test_ItvMapGroupigValidater();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_itv_map_settic/labat_itv_map_settic.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itv_map_settic/labat_itv_map_settic.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itv_map_settic/labat_itv_map_settic.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -47,6 +47,6 @@
int main()
{
- test_ItvMapSetticValidater();
+ test_ItvMapSetticValidater();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_itv_set/labat_itv_set.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itv_set/labat_itv_set.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itv_set/labat_itv_set.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -47,6 +47,6 @@
int main()
{
- test_ItvSetValidater();
+ test_ItvSetValidater();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_signed_quantifier/labat_signed_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_signed_quantifier/labat_signed_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_signed_quantifier/labat_signed_quantifier.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -31,6 +31,6 @@
int main()
{
- test_signed_quantifier_driver();
+ test_signed_quantifier_driver();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_single/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single/labat_single.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -43,37 +43,37 @@
//map_cluster_star_pushout.setTrialsCount(1000);
//map_cluster_star_pushout.run();
- //typedef InplaceFlip
- // <interval_map<int, nat> > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
-
- //typedef InplaceAssociativity
- // <itl::interval_map<int, int, partial_absorber>, inplace_et> TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
-
- typedef InducedRelation
- <itl::interval_map<int, int, partial_enricher>,
- typename itl::interval_map<int, int, partial_enricher>::atomized_type,
- Interval::Atomize, protonic_equal> TestLawT;
- LawValidater<TestLawT, RandomGentor> test_law;
-
- //-----------------------------------------------------------------------------
- int test_count = 10000;
- ptime start, stop;
-
- test_law.setTrialsCount(test_count);
-
- std::cout << "Start\n";
- start = ptime(microsec_clock::local_time());
- test_law.run();
- stop = ptime(microsec_clock::local_time());
- std::cout << "Stop. Time elapsed: " << stop - start << endl;
+ //typedef InplaceFlip
+ // <interval_map<int, nat> > TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+
+ //typedef InplaceAssociativity
+ // <itl::interval_map<int, int, partial_absorber>, inplace_et> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+
+ typedef InducedRelation
+ <itl::interval_map<int, int, partial_enricher>,
+ typename itl::interval_map<int, int, partial_enricher>::atomized_type,
+ Interval::Atomize, protonic_equal> TestLawT;
+ LawValidater<TestLawT, RandomGentor> test_law;
+
+ //-----------------------------------------------------------------------------
+ int test_count = 10000;
+ ptime start, stop;
+
+ test_law.setTrialsCount(test_count);
+
+ std::cout << "Start\n";
+ start = ptime(microsec_clock::local_time());
+ test_law.run();
+ stop = ptime(microsec_clock::local_time());
+ std::cout << "Stop. Time elapsed: " << stop - start << endl;
}
int main()
{
- test_LawValidater();
- return 0;
+ test_LawValidater();
+ return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_unsigned_quantifier/labat_unsigned_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_unsigned_quantifier/labat_unsigned_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_unsigned_quantifier/labat_unsigned_quantifier.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -32,6 +32,6 @@
int main()
{
- test_unsigned_quantifier_driver();
+ test_unsigned_quantifier_driver();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_val_relations/labat_val_relations.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_val_relations/labat_val_relations.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_val_relations/labat_val_relations.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
#include <boost/validate/itl_relations_validater.hpp>
@@ -30,6 +30,6 @@
int main()
{
- test_Validater();
+ test_Validater();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labat_val_setbase/labat_val_setbase.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_val_setbase/labat_val_setbase.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_val_setbase/labat_val_setbase.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
#include <boost/validate/itl_setbase_validater.hpp>
@@ -32,6 +32,6 @@
int main()
{
- test_Validater();
+ test_Validater();
return 0;
}
Modified: sandbox/itl/libs/validate/example/labatea/labatea.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labatea/labatea.cpp (original)
+++ sandbox/itl/libs/validate/example/labatea/labatea.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
A Law Based Test Automaton 'LaBatea'
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
@@ -57,43 +57,43 @@
//map_cluster_star_pushout.setTrialsCount(1000);
//map_cluster_star_pushout.run();
- //typedef InplaceSymmetricDifference<interval_map<int, itl::set<int>, total_enricher >, std_equal> TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
- //test_law.setTrialsCount(1000);
- //test_law.run();
-
- //typedef InplaceDistributivity
- // <split_interval_map<int, itl::set<int>, partial_absorber >,
- // inplace_et, inplace_plus, itl::std_equal> TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
- //test_law.setTrialsCount(1000);
-
- typedef InplaceNaturalInversion
- <split_interval_map<int, itl::set<int>, total_absorber >,
- itl::inplace_plus, itl::protonic_equal> TestLawT;
- LawValidater<TestLawT, RandomGentor> test_law;
- test_law.setTrialsCount(1000);
-
- //typedef InplaceAssociativity
- // <interval_map<int, int, partial_absorber >, inplace_plus> TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
- //test_law.setTrialsCount(1000);
-
- //typedef InplaceCommutativity
- // <split_interval_map<int, int, total_absorber>, inplace_plus> TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
- //test_law.setTrialsCount(1000);
-
- //typedef ProtonicEquality
- // <split_interval_map<int, int, partial_enricher > > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
- //test_law.setTrialsCount(1000);
-
- std::cout << "Start\n";
- ptime start(microsec_clock::local_time());
- test_law.run();
- ptime stop(microsec_clock::local_time());
- std::cout << "Stop. Time elapsed: " << stop - start << endl;
+ //typedef InplaceSymmetricDifference<interval_map<int, itl::set<int>, total_enricher >, std_equal> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+ //test_law.run();
+
+ //typedef InplaceDistributivity
+ // <split_interval_map<int, itl::set<int>, partial_absorber >,
+ // inplace_et, inplace_plus, itl::std_equal> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+
+ typedef InplaceNaturalInversion
+ <split_interval_map<int, itl::set<int>, total_absorber >,
+ itl::inplace_plus, itl::protonic_equal> TestLawT;
+ LawValidater<TestLawT, RandomGentor> test_law;
+ test_law.setTrialsCount(1000);
+
+ //typedef InplaceAssociativity
+ // <interval_map<int, int, partial_absorber >, inplace_plus> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+
+ //typedef InplaceCommutativity
+ // <split_interval_map<int, int, total_absorber>, inplace_plus> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+
+ //typedef ProtonicEquality
+ // <split_interval_map<int, int, partial_enricher > > TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+
+ std::cout << "Start\n";
+ ptime start(microsec_clock::local_time());
+ test_law.run();
+ ptime stop(microsec_clock::local_time());
+ std::cout << "Stop. Time elapsed: " << stop - start << endl;
}
void test_realmvalidater()
Modified: sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp
==============================================================================
--- sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp (original)
+++ sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp 2009-02-24 14:48:07 EST (Tue, 24 Feb 2009)
@@ -1,12 +1,12 @@
-/*----------------------------------------------------------------------------+
+/*-----------------------------------------------------------------------------+
Interval Template Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
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)
-+----------------------------------------------------------------------------*/
++-----------------------------------------------------------------------------*/
#include <boost/validate/gentor/gentorprofile.hpp>
using namespace boost::itl;
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk