|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65970 - in sandbox/itl: boost/itl boost/itl/concept boost/itl/concept/interval boost/itl/detail boost/itl/type_traits boost/itl_xt boost/itl_xt/detail boost/itl_xt/std boost/validate boost/validate/driver boost/validate/gentor boost/validate/itl boost/validate/laws boost/validate/loki_xt boost/validate/std/algorithm boost/validate/type boost/validate/validater libs/itl/doxy_doc/doxygen_input/pages libs/itl/example libs/itl/example/boost_party_ libs/itl/example/custom_interval_ libs/itl/example/interval_ libs/itl/example/interval_container_ libs/itl/example/itvset_shell_ libs/itl/example/large_bitset_ libs/itl/example/man_power_ libs/itl/example/month_and_week_grid_ libs/itl/example/overlap_counter_ libs/itl/example/party_ libs/itl/example/partys_height_average_ libs/itl/example/partys_tallest_guests_ libs/itl/example/splititvmap_shell_ libs/itl/example/std_copy_ libs/itl/example/std_transform_ libs/itl/example/user_groups_ libs/itl/test libs/itl/test/fastest_interval_map_ libs/itl/test/fastest_interval_map_infix_ libs/itl/test/fastest_interval_map_infix_mixed_ libs/itl/test/fastest_interval_map_mixed2_ libs/itl/test/fastest_interval_map_mixed_ libs/itl/test/fastest_interval_set_ libs/itl/test/fastest_interval_set_infix_ libs/itl/test/fastest_interval_set_mixed_ libs/itl/test/fastest_itl_interval_ libs/itl/test/fastest_itl_map_ libs/itl/test/fastest_partial_icl_quantifier_ libs/itl/test/fastest_partial_interval_quantifier_ libs/itl/test/fastest_separate_interval_set_ libs/itl/test/fastest_separate_interval_set_infix_ libs/itl/test/fastest_set_interval_set_ libs/itl/test/fastest_set_itl_set_ libs/itl/test/fastest_split_interval_map_ libs/itl/test/fastest_split_interval_map_infix_ libs/itl/test/fastest_split_interval_set_ libs/itl/test/fastest_split_interval_set_infix_ libs/itl/test/fastest_total_icl_quantifier_ libs/itl/test/fastest_total_interval_quantifier_ libs/itl/test/test_casual_ libs/itl/test/test_combinable_ libs/itl/test/test_continuous_interval_ libs/itl/test/test_interval_map_ libs/itl/test/test_interval_map_infix_ libs/itl/test/test_interval_map_infix_mixed_ libs/itl/test/test_interval_map_mixed2_ libs/itl/test/test_interval_map_mixed_ libs/itl/test/test_interval_set_ libs/itl/test/test_interval_set_infix_ libs/itl/test/test_interval_set_mixed_ libs/itl/test/test_itl_interval_ libs/itl/test/test_itl_map_ libs/itl/test/test_partial_icl_quantifier_ libs/itl/test/test_partial_interval_quantifier_ libs/itl/test/test_separate_interval_set_ libs/itl/test/test_separate_interval_set_infix_ libs/itl/test/test_set_interval_set_ libs/itl/test/test_set_itl_set_ libs/itl/test/test_split_interval_map_ libs/itl/test/test_split_interval_map_infix_ libs/itl/test/test_split_interval_set_ libs/itl/test/test_split_interval_set_infix_ libs/itl/test/test_total_icl_quantifier_ libs/itl/test/test_total_interval_quantifier_ 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/boostcon_abelian_monoids_ libs/validate/example/boostcon_law_validater_ libs/validate/example/de_morgan_ libs/validate/example/labat_bit_collector_ libs/validate/example/labat_collector_ libs/validate/example/labat_itl_morphic_ libs/validate/example/labat_itl_set_ libs/validate/example/labat_itv_bitset_ libs/validate/example/labat_map_copy_conformity_ libs/validate/example/labat_map_order_ libs/validate/example/labat_polygon_ libs/validate/example/labat_set_copy_conformity_ libs/validate/example/labat_set_order_ libs/validate/example/labat_signed_quantifier_ libs/validate/example/labat_single_ libs/validate/example/labat_sorted_assoc_bitset_ libs/validate/example/labat_sorted_assoc_bitset_back_ libs/validate/example/labat_sorted_assoc_map_ libs/validate/example/labat_sorted_assoc_map_back_ libs/validate/example/labat_sorted_assoc_set_ libs/validate/example/labat_sorted_assoc_set_back_ libs/validate/example/labat_unsigned_quantifier_ libs/validate/example/labat_val_relations_ libs/validate/src/gentor libs/validate/test/test_bit_collector_ libs/validate/test/test_collector_ libs/validate/test/test_interval_bitset_ libs/validate/test/test_itl_morphic_ libs/validate/test/test_itl_set_ libs/validate/test/test_map_copy_conformity_ libs/validate/test/test_map_order_ libs/validate/test/test_set_copy_conformity_ libs/validate/test/test_set_order_ libs/validate/test/test_signed_quantifier_ libs/validate/test/test_sorted_assoc_bitset_ libs/validate/test/test_sorted_assoc_bitset_back_ libs/validate/test/test_sorted_assoc_map_ libs/validate/test/test_sorted_assoc_map_back_ libs/validate/test/test_sorted_assoc_set_ libs/validate/test/test_sorted_assoc_set_back_ libs/validate/test/test_unsigned_quantifier_ libs/validate/test/test_val_relations_
From: afojgo_at_[hidden]
Date: 2010-10-15 04:58:49
Author: jofaber
Date: 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
New Revision: 65970
URL: http://svn.boost.org/trac/boost/changeset/65970
Log:
Refactoring: Renamed all occurrences of itl with icl, and Interval Template Library with Interval Container Library. Stable{msvc-9.0, 10.0, gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/closed_interval.hpp | 18 +-
sandbox/itl/boost/itl/concept/comparable.hpp | 2
sandbox/itl/boost/itl/concept/container.hpp | 2
sandbox/itl/boost/itl/concept/element_associator.hpp | 42 +++---
sandbox/itl/boost/itl/concept/element_map.hpp | 28 ++--
sandbox/itl/boost/itl/concept/element_set.hpp | 8
sandbox/itl/boost/itl/concept/element_set_value.hpp | 2
sandbox/itl/boost/itl/concept/interval.hpp | 118 ++++++++++----------
sandbox/itl/boost/itl/concept/interval/base.hpp | 4
sandbox/itl/boost/itl/concept/interval_associator.hpp | 50 ++++----
sandbox/itl/boost/itl/concept/interval_bounds.hpp | 12 +-
sandbox/itl/boost/itl/concept/interval_map.hpp | 54 ++++----
sandbox/itl/boost/itl/concept/interval_set.hpp | 40 +++---
sandbox/itl/boost/itl/concept/interval_set_value.hpp | 4
sandbox/itl/boost/itl/concept/map_value.hpp | 2
sandbox/itl/boost/itl/concept/set_value.hpp | 2
sandbox/itl/boost/itl/continuous_interval.hpp | 32 ++--
sandbox/itl/boost/itl/detail/associated_value.hpp | 4
sandbox/itl/boost/itl/detail/concept_check.hpp | 2
sandbox/itl/boost/itl/detail/design_config.hpp | 8
sandbox/itl/boost/itl/detail/element_comparer.hpp | 4
sandbox/itl/boost/itl/detail/element_iterator.hpp | 20 +-
sandbox/itl/boost/itl/detail/exclusive_less_than.hpp | 4
sandbox/itl/boost/itl/detail/interval_map_algo.hpp | 18 +-
sandbox/itl/boost/itl/detail/interval_morphism.hpp | 14 +-
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 30 ++--
sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp | 10
sandbox/itl/boost/itl/detail/map_algo.hpp | 4
sandbox/itl/boost/itl/detail/mapped_reference.hpp | 4
sandbox/itl/boost/itl/detail/notate.hpp | 4
sandbox/itl/boost/itl/detail/on_absorbtion.hpp | 2
sandbox/itl/boost/itl/detail/relation_state.hpp | 4
sandbox/itl/boost/itl/detail/set_algo.hpp | 22 +-
sandbox/itl/boost/itl/detail/std_set.hpp | 4
sandbox/itl/boost/itl/detail/subset_comparer.hpp | 4
sandbox/itl/boost/itl/discrete_interval.hpp | 24 ++--
sandbox/itl/boost/itl/dynamic_interval_traits.hpp | 2
sandbox/itl/boost/itl/functors.hpp | 108 +++++++++---------
sandbox/itl/boost/itl/gregorian.hpp | 4
sandbox/itl/boost/itl/interval.hpp | 18 +-
sandbox/itl/boost/itl/interval_base_map.hpp | 136 +++++++++++-----------
sandbox/itl/boost/itl/interval_base_set.hpp | 58 ++++----
sandbox/itl/boost/itl/interval_bounds.hpp | 4
sandbox/itl/boost/itl/interval_combining_style.hpp | 2
sandbox/itl/boost/itl/interval_map.hpp | 32 ++--
sandbox/itl/boost/itl/interval_set.hpp | 22 +-
sandbox/itl/boost/itl/interval_traits.hpp | 2
sandbox/itl/boost/itl/iterator.hpp | 4
sandbox/itl/boost/itl/left_open_interval.hpp | 16 +-
sandbox/itl/boost/itl/map.hpp | 40 +++---
sandbox/itl/boost/itl/open_interval.hpp | 16 +-
sandbox/itl/boost/itl/predicates.hpp | 14 +-
sandbox/itl/boost/itl/ptime.hpp | 4
sandbox/itl/boost/itl/rational.hpp | 4
sandbox/itl/boost/itl/right_open_interval.hpp | 16 +-
sandbox/itl/boost/itl/separate_interval_set.hpp | 22 +-
sandbox/itl/boost/itl/set.hpp | 28 ++--
sandbox/itl/boost/itl/split_interval_map.hpp | 36 +++---
sandbox/itl/boost/itl/split_interval_set.hpp | 22 +-
sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp | 2
sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp | 2
sandbox/itl/boost/itl/type_traits/adds_inversely.hpp | 2
sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/difference.hpp | 2
sandbox/itl/boost/itl/type_traits/difference_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/domain_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/element_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/has_inverse.hpp | 2
sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp | 2
sandbox/itl/boost/itl/type_traits/identity_element.hpp | 2
sandbox/itl/boost/itl/type_traits/infinity.hpp | 2
sandbox/itl/boost/itl/type_traits/interval_type_default.hpp | 2
sandbox/itl/boost/itl/type_traits/interval_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp | 2
sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 4
sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp | 2
sandbox/itl/boost/itl/type_traits/is_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_continuous.hpp | 2
sandbox/itl/boost/itl/type_traits/is_continuous_interval.hpp | 2
sandbox/itl/boost/itl/type_traits/is_discrete.hpp | 2
sandbox/itl/boost/itl/type_traits/is_discrete_interval.hpp | 2
sandbox/itl/boost/itl/type_traits/is_element_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_icl_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_interval.hpp | 2
sandbox/itl/boost/itl/type_traits/is_interval_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_interval_joiner.hpp | 2
sandbox/itl/boost/itl/type_traits/is_interval_separator.hpp | 2
sandbox/itl/boost/itl/type_traits/is_interval_splitter.hpp | 2
sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp | 2
sandbox/itl/boost/itl/type_traits/is_map.hpp | 2
sandbox/itl/boost/itl/type_traits/is_numeric.hpp | 2
sandbox/itl/boost/itl/type_traits/is_set.hpp | 2
sandbox/itl/boost/itl/type_traits/is_total.hpp | 2
sandbox/itl/boost/itl/type_traits/no_type.hpp | 2
sandbox/itl/boost/itl/type_traits/segment_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/size.hpp | 2
sandbox/itl/boost/itl/type_traits/size_type_of.hpp | 2
sandbox/itl/boost/itl/type_traits/succ_pred.hpp | 2
sandbox/itl/boost/itl/type_traits/to_string.hpp | 2
sandbox/itl/boost/itl/type_traits/type_to_string.hpp | 2
sandbox/itl/boost/itl/type_traits/unit_element.hpp | 4
sandbox/itl/boost/itl/type_traits/value_size.hpp | 4
sandbox/itl/boost/itl_xt/bits.hpp | 18 +-
sandbox/itl/boost/itl_xt/bits_gentor.hpp | 10
sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 10
sandbox/itl/boost/itl_xt/enum_bitset.hpp | 4
sandbox/itl/boost/itl_xt/episode_product.hpp | 12 +-
sandbox/itl/boost/itl_xt/episode_set.hpp | 8
sandbox/itl/boost/itl_xt/fixtupelconst.hpp | 4
sandbox/itl/boost/itl_xt/gentorit.hpp | 4
sandbox/itl/boost/itl_xt/group_order.hpp | 4
sandbox/itl/boost/itl_xt/grouping.hpp | 10
sandbox/itl/boost/itl_xt/interval_bitset.hpp | 44 +++---
sandbox/itl/boost/itl_xt/itvgentor.hpp | 12 +-
sandbox/itl/boost/itl_xt/list.hpp | 26 ++--
sandbox/itl/boost/itl_xt/map_segment_gentor.hpp | 10
sandbox/itl/boost/itl_xt/mapgentor.hpp | 14 +-
sandbox/itl/boost/itl_xt/meta_log.hpp | 4
sandbox/itl/boost/itl_xt/numbergentor.hpp | 18 +-
sandbox/itl/boost/itl_xt/ordered_type.hpp | 4
sandbox/itl/boost/itl_xt/prefix_set.cpp | 2
sandbox/itl/boost/itl_xt/prefix_set.hpp | 4
sandbox/itl/boost/itl_xt/product_history.hpp | 4
sandbox/itl/boost/itl_xt/random.hpp | 8
sandbox/itl/boost/itl_xt/randomnumber.hpp | 2
sandbox/itl/boost/itl_xt/seqgentor.hpp | 10
sandbox/itl/boost/itl_xt/setgentor.hpp | 12 +-
sandbox/itl/boost/itl_xt/statvardesct.hpp | 4
sandbox/itl/boost/itl_xt/std/pair.hpp | 4
sandbox/itl/boost/itl_xt/std/pair_gentor.hpp | 4
sandbox/itl/boost/itl_xt/string_list.cpp | 2
sandbox/itl/boost/itl_xt/string_list.hpp | 6
sandbox/itl/boost/itl_xt/string_map.hpp | 4
sandbox/itl/boost/itl_xt/string_set.hpp | 6
sandbox/itl/boost/itl_xt/string_sheet.cpp | 2
sandbox/itl/boost/itl_xt/string_sheet.hpp | 4
sandbox/itl/boost/itl_xt/stringpattern_set.hpp | 4
sandbox/itl/boost/itl_xt/tuple_computer.hpp | 22 +-
sandbox/itl/boost/itl_xt/typed_episode.hpp | 6
sandbox/itl/boost/itl_xt/var_permutation.hpp | 8
sandbox/itl/boost/itl_xt/var_tuple.hpp | 8
sandbox/itl/boost/itl_xt/var_tuple_inscriptor.hpp | 4
sandbox/itl/boost/itl_xt/var_tuple_order.hpp | 12 +-
sandbox/itl/boost/validate/driver/abelian_monoid_driver.hpp | 8
sandbox/itl/boost/validate/driver/bit_collector_driver.hpp | 16 +-
sandbox/itl/boost/validate/driver/collector_driver.hpp | 10
sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp | 4
sandbox/itl/boost/validate/driver/itl_driver.hpp | 16 +-
sandbox/itl/boost/validate/driver/itl_morphic_driver.hpp | 4
sandbox/itl/boost/validate/driver/itl_relations_driver.hpp | 4
sandbox/itl/boost/validate/driver/itl_set_driver.hpp | 4
sandbox/itl/boost/validate/driver/itl_single_law_driver.hpp | 4
sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp | 32 ++--
sandbox/itl/boost/validate/driver/map_order_driver.hpp | 16 +-
sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp | 12 +-
sandbox/itl/boost/validate/driver/set_order_driver.hpp | 4
sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp | 12 +-
sandbox/itl/boost/validate/driver/sorted_associative_bitset_back_driver.hpp | 12 +-
sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp | 12 +-
sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp | 20 +-
sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp | 20 +-
sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp | 10
sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp | 10
sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp | 12 +-
sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 76 ++++++------
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 234 ++++++++++++++++++++--------------------
sandbox/itl/boost/validate/gentor/rangegentor.hpp | 16 +-
sandbox/itl/boost/validate/itl/functors.hpp | 22 +-
sandbox/itl/boost/validate/laws/algo_equivalence.hpp | 4
sandbox/itl/boost/validate/laws/atomic_equivalence.hpp | 16 +-
sandbox/itl/boost/validate/laws/element_order.hpp | 4
sandbox/itl/boost/validate/laws/function_equality.hpp | 6
sandbox/itl/boost/validate/laws/induced_relation.hpp | 4
sandbox/itl/boost/validate/laws/inversion_laws.hpp | 14 +-
sandbox/itl/boost/validate/laws/law.hpp | 4
sandbox/itl/boost/validate/laws/law_violations.hpp | 10
sandbox/itl/boost/validate/laws/map_laws.hpp | 6
sandbox/itl/boost/validate/laws/minor_set_laws.hpp | 4
sandbox/itl/boost/validate/laws/monoid.hpp | 6
sandbox/itl/boost/validate/laws/order.hpp | 6
sandbox/itl/boost/validate/laws/pushouts.hpp | 4
sandbox/itl/boost/validate/laws/set_laws.hpp | 10
sandbox/itl/boost/validate/laws/subset_order.hpp | 4
sandbox/itl/boost/validate/laws/symmetric_difference.hpp | 14 +-
sandbox/itl/boost/validate/loki_xt/Tuple.h | 6
sandbox/itl/boost/validate/loki_xt/TupleGentor.h | 6
sandbox/itl/boost/validate/std/algorithm/copy.hpp | 4
sandbox/itl/boost/validate/std/algorithm/find.hpp | 4
sandbox/itl/boost/validate/std/algorithm/relation.hpp | 4
sandbox/itl/boost/validate/std/algorithm/set_algo.hpp | 4
sandbox/itl/boost/validate/type/bits.hpp | 18 +-
sandbox/itl/boost/validate/type/nat.hpp | 10
sandbox/itl/boost/validate/utility.hpp | 4
sandbox/itl/boost/validate/validater/abelian_monoid_validater.hpp | 4
sandbox/itl/boost/validate/validater/bit_collector_validater.hpp | 16 +-
sandbox/itl/boost/validate/validater/collector_validater.hpp | 16 +-
sandbox/itl/boost/validate/validater/concept_validater.hpp | 4
sandbox/itl/boost/validate/validater/function_equality_validater.hpp | 4
sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp | 4
sandbox/itl/boost/validate/validater/itl_induced_relations.hpp | 4
sandbox/itl/boost/validate/validater/itl_order_validater.hpp | 6
sandbox/itl/boost/validate/validater/itl_set_validater.hpp | 16 +-
sandbox/itl/boost/validate/validater/law_validater.hpp | 14 +-
sandbox/itl/boost/validate/validater/monoid_validater.hpp | 4
sandbox/itl/boost/validate/validater/partial_order_validater.hpp | 6
sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp | 4
sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp | 6
sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp | 6
sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp | 4
sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp | 4
sandbox/itl/boost/validate/validation_counts.hpp | 4
sandbox/itl/libs/itl/doxy_doc/doxygen_input/pages/doxygen_mainpage.hpp | 10
sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp | 8
sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp | 8
sandbox/itl/libs/itl/example/interval_/interval.cpp | 8
sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp | 8
sandbox/itl/libs/itl/example/itvset_shell_/itvset_shell.cpp | 6
sandbox/itl/libs/itl/example/large_bitset_/bits.hpp | 2
sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp | 4
sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp | 18 +-
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/partys_height_average_/partys_height_average.cpp | 8
sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp | 8
sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp | 6
sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp | 30 ++--
sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp | 36 +++---
sandbox/itl/libs/itl/example/toytime.hpp | 6
sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp | 12 +-
sandbox/itl/libs/itl/test/fastest_interval_map_/fastest_interval_map.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_map_infix_/fastest_interval_map_infix.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_map_infix_mixed_/fastest_interval_map_infix_mixed.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_map_mixed2_/fastest_interval_map_mixed2.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_map_mixed_/fastest_interval_map_mixed.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_set_/fastest_interval_set.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_set_infix_/fastest_interval_set_infix.cpp | 4
sandbox/itl/libs/itl/test/fastest_interval_set_mixed_/fastest_interval_set_mixed.cpp | 4
sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp | 4
sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map.cpp | 4
sandbox/itl/libs/itl/test/fastest_partial_icl_quantifier_/fastest_partial_icl_quantifier.cpp | 4
sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp | 4
sandbox/itl/libs/itl/test/fastest_separate_interval_set_/fastest_separate_interval_set.cpp | 4
sandbox/itl/libs/itl/test/fastest_separate_interval_set_infix_/fastest_separate_interval_set_infix.cpp | 4
sandbox/itl/libs/itl/test/fastest_set_interval_set_/fastest_set_interval_set.cpp | 4
sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set.cpp | 4
sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set_cases.hpp | 2
sandbox/itl/libs/itl/test/fastest_split_interval_map_/fastest_split_interval_map.cpp | 4
sandbox/itl/libs/itl/test/fastest_split_interval_map_infix_/fastest_split_interval_map_infix.cpp | 4
sandbox/itl/libs/itl/test/fastest_split_interval_set_/fastest_split_interval_set.cpp | 4
sandbox/itl/libs/itl/test/fastest_split_interval_set_infix_/fastest_split_interval_set_infix.cpp | 4
sandbox/itl/libs/itl/test/fastest_total_icl_quantifier_/fastest_total_icl_quantifier.cpp | 4
sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_/fastest_total_interval_quantifier.cpp | 4
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 120 ++++++++++----------
sandbox/itl/libs/itl/test/test_combinable_/test_combinable.cpp | 4
sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp | 4
sandbox/itl/libs/itl/test/test_functions.hpp | 12 +-
sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp | 10
sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp | 4
sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp | 34 ++--
sandbox/itl/libs/itl/test/test_icl_interval.hpp | 62 +++++-----
sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp | 66 +++++-----
sandbox/itl/libs/itl/test/test_icl_static_interval.hpp | 8
sandbox/itl/libs/itl/test/test_interval_laws.hpp | 66 +++++-----
sandbox/itl/libs/itl/test/test_interval_map_/test_interval_map.cpp | 4
sandbox/itl/libs/itl/test/test_interval_map_infix_/test_interval_map_infix.cpp | 4
sandbox/itl/libs/itl/test/test_interval_map_infix_mixed_/test_interval_map_infix_mixed.cpp | 4
sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 162 +++++++++++++-------------
sandbox/itl/libs/itl/test/test_interval_map_mixed2_/test_interval_map_mixed2.cpp | 4
sandbox/itl/libs/itl/test/test_interval_map_mixed_/test_interval_map_mixed.cpp | 4
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 216 ++++++++++++++++++------------------
sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp | 36 +++---
sandbox/itl/libs/itl/test/test_interval_set_/test_interval_set.cpp | 4
sandbox/itl/libs/itl/test/test_interval_set_infix_/test_interval_set_infix.cpp | 4
sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp | 12 +-
sandbox/itl/libs/itl/test/test_interval_set_mixed_/test_interval_set_mixed.cpp | 4
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 58 ++++----
sandbox/itl/libs/itl/test/test_itl_interval.hpp | 14 +-
sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp | 4
sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp | 132 +++++++++++-----------
sandbox/itl/libs/itl/test/test_itl_map.hpp | 28 ++--
sandbox/itl/libs/itl/test/test_itl_map_/test_itl_map.cpp | 4
sandbox/itl/libs/itl/test/test_laws.hpp | 68 +++++-----
sandbox/itl/libs/itl/test/test_partial_icl_quantifier_/test_partial_icl_quantifier.cpp | 4
sandbox/itl/libs/itl/test/test_partial_interval_quantifier_/test_partial_interval_quantifier.cpp | 4
sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp | 48 ++++----
sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 32 ++--
sandbox/itl/libs/itl/test/test_separate_interval_set_/test_separate_interval_set.cpp | 4
sandbox/itl/libs/itl/test/test_separate_interval_set_infix_/test_separate_interval_set_infix.cpp | 4
sandbox/itl/libs/itl/test/test_set_interval_set_/test_set_interval_set.cpp | 4
sandbox/itl/libs/itl/test/test_set_itl_set.hpp | 10
sandbox/itl/libs/itl/test/test_set_itl_set_/test_set_itl_set.cpp | 4
sandbox/itl/libs/itl/test/test_set_itl_set_/test_set_itl_set_cases.hpp | 2
sandbox/itl/libs/itl/test/test_split_interval_map_/test_split_interval_map.cpp | 4
sandbox/itl/libs/itl/test/test_split_interval_map_infix_/test_split_interval_map_infix.cpp | 4
sandbox/itl/libs/itl/test/test_split_interval_set_/test_split_interval_set.cpp | 4
sandbox/itl/libs/itl/test/test_split_interval_set_infix_/test_split_interval_set_infix.cpp | 4
sandbox/itl/libs/itl/test/test_total_icl_quantifier_/test_total_icl_quantifier.cpp | 4
sandbox/itl/libs/itl/test/test_total_interval_quantifier_/test_total_interval_quantifier.cpp | 4
sandbox/itl/libs/itl/test/test_value_maker.hpp | 10
sandbox/itl/libs/itl_xt/example/amount_cube_/amount_cube.cpp | 8
sandbox/itl/libs/itl_xt/example/history_/history.cpp | 8
sandbox/itl/libs/itl_xt/example/toytime.h | 4
sandbox/itl/libs/itl_xt/test/auto_itv_test_/auto_itv_test.cpp | 4
sandbox/itl/libs/itl_xt/test/itvmaptester.h | 4
sandbox/itl/libs/itl_xt/test/itvsettester.h | 4
sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp | 6
sandbox/itl/libs/validate/example/boostcon_abelian_monoids_/boostcon_abelian_monoids.cpp | 2
sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp | 4
sandbox/itl/libs/validate/example/de_morgan_/de_morgan.cpp | 2
sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp | 2
sandbox/itl/libs/validate/example/labat_collector_/labat_collector.cpp | 2
sandbox/itl/libs/validate/example/labat_itl_morphic_/labat_itl_morphic.cpp | 2
sandbox/itl/libs/validate/example/labat_itl_set_/labat_itl_set.cpp | 2
sandbox/itl/libs/validate/example/labat_itv_bitset_/labat_itv_bitset.cpp | 2
sandbox/itl/libs/validate/example/labat_map_copy_conformity_/labat_map_copy_conformity.cpp | 2
sandbox/itl/libs/validate/example/labat_map_order_/labat_map_order.cpp | 2
sandbox/itl/libs/validate/example/labat_polygon_/custom_polygon.hpp | 6
sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp | 6
sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp | 10
sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp | 2
sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp | 4
sandbox/itl/libs/validate/example/labat_set_copy_conformity_/labat_set_copy_conformity.cpp | 2
sandbox/itl/libs/validate/example/labat_set_order_/labat_set_order.cpp | 2
sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp | 2
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 30 ++--
sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_/labat_sorted_assoc_bitset.cpp | 2
sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_back_/labat_sorted_assoc_bitset_back.cpp | 2
sandbox/itl/libs/validate/example/labat_sorted_assoc_map_/labat_sorted_assoc_map.cpp | 2
sandbox/itl/libs/validate/example/labat_sorted_assoc_map_back_/labat_sorted_assoc_map_back.cpp | 2
sandbox/itl/libs/validate/example/labat_sorted_assoc_set_/labat_sorted_assoc_set.cpp | 2
sandbox/itl/libs/validate/example/labat_sorted_assoc_set_back_/labat_sorted_assoc_set_back.cpp | 2
sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/labat_unsigned_quantifier.cpp | 2
sandbox/itl/libs/validate/example/labat_val_relations_/labat_val_relations.cpp | 2
sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp | 6
sandbox/itl/libs/validate/test/test_bit_collector_/test_bit_collector.cpp | 2
sandbox/itl/libs/validate/test/test_collector_/test_collector.cpp | 2
sandbox/itl/libs/validate/test/test_interval_bitset_/test_interval_bitset.cpp | 2
sandbox/itl/libs/validate/test/test_itl_morphic_/test_itl_morphic.cpp | 2
sandbox/itl/libs/validate/test/test_itl_set_/test_itl_set.cpp | 2
sandbox/itl/libs/validate/test/test_map_copy_conformity_/test_map_copy_conformity.cpp | 2
sandbox/itl/libs/validate/test/test_map_order_/test_map_order.cpp | 2
sandbox/itl/libs/validate/test/test_set_copy_conformity_/test_set_copy_conformity.cpp | 2
sandbox/itl/libs/validate/test/test_set_order_/test_set_order.cpp | 2
sandbox/itl/libs/validate/test/test_signed_quantifier_/test_signed_quantifier.cpp | 2
sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_/test_sorted_assoc_bitset.cpp | 2
sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_back_/test_sorted_assoc_bitset_back.cpp | 2
sandbox/itl/libs/validate/test/test_sorted_assoc_map_/test_sorted_assoc_map.cpp | 2
sandbox/itl/libs/validate/test/test_sorted_assoc_map_back_/test_sorted_assoc_map_back.cpp | 2
sandbox/itl/libs/validate/test/test_sorted_assoc_set_/test_sorted_assoc_set.cpp | 2
sandbox/itl/libs/validate/test/test_sorted_assoc_set_back_/test_sorted_assoc_set_back.cpp | 2
sandbox/itl/libs/validate/test/test_unsigned_quantifier_/test_unsigned_quantifier.cpp | 2
sandbox/itl/libs/validate/test/test_val_relations_/test_val_relations.cpp | 2
356 files changed, 2175 insertions(+), 2175 deletions(-)
Modified: sandbox/itl/boost/itl/closed_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/closed_interval.hpp (original)
+++ sandbox/itl/boost/itl/closed_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class DomainT,
@@ -33,7 +33,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
}
//NOTE: Compiler generated copy constructor is used
@@ -44,7 +44,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((!itl::is_continuous<DomainT>::value));
+ BOOST_STATIC_ASSERT((!icl::is_continuous<DomainT>::value));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
@@ -71,11 +71,11 @@
//=T closed_interval -> concept intervals
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::closed_interval<DomainT, Compare> >
+struct interval_traits< icl::closed_interval<DomainT, Compare> >
{
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::closed_interval<DomainT, Compare> interval_type;
+ typedef icl::closed_interval<DomainT, Compare> interval_type;
static interval_type construct(const domain_type& lo, const domain_type& up)
{
@@ -97,20 +97,20 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::closed_interval<DomainT,Compare> >
+struct type_to_string<icl::closed_interval<DomainT,Compare> >
{
static std::string apply()
{ return "[I]<"+ type_to_string<DomainT>::apply() +">"; }
};
template<class DomainT>
-struct value_size<itl::closed_interval<DomainT> >
+struct value_size<icl::closed_interval<DomainT> >
{
- static std::size_t apply(const itl::closed_interval<DomainT>& value)
+ static std::size_t apply(const icl::closed_interval<DomainT>& value)
{ return 2; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/concept/comparable.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/comparable.hpp (original)
+++ sandbox/itl/boost/itl/concept/comparable.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_icl_container.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/container.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/container.hpp (original)
+++ sandbox/itl/boost/itl/concept/container.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/is_container.hpp>
#include <boost/itl/type_traits/is_icl_container.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/element_associator.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_associator.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_associator.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/concept/element_set.hpp>
#include <boost/itl/concept/element_map.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
@@ -31,14 +31,14 @@
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
size(const Type& object)
{
- return itl::iterative_size(object);
+ return icl::iterative_size(object);
}
template<class Type>
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
cardinality(const Type& object)
{
- return itl::iterative_size(object);
+ return icl::iterative_size(object);
}
@@ -65,9 +65,9 @@
bool>::type
within(const SubT& sub, const SuperT& super)
{
- if(itl::is_empty(sub)) return true;
- if(itl::is_empty(super)) return false;
- if(itl::size(super) < itl::size(sub)) return false;
+ if(icl::is_empty(sub)) return true;
+ if(icl::is_empty(super)) return false;
+ if(icl::size(super) < icl::size(sub)) return false;
typename SubT::const_iterator common_lwb_;
typename SubT::const_iterator common_upb_;
@@ -96,7 +96,7 @@
typename enable_if<is_associative_element_container<Type>, bool>::type
contains(const Type& super, const typename Type::key_type& key)
{
- return itl::within(key, super);
+ return icl::within(key, super);
}
//------------------------------------------------------------------------------
@@ -108,7 +108,7 @@
bool>::type
contains(const SuperT& super, const SubT& sub)
{
- return itl::within(sub, super);
+ return icl::within(sub, super);
}
//==============================================================================
@@ -168,7 +168,7 @@
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
operator += (Type& object, const typename Type::value_type& operand)
{
- return itl::add(object, operand);
+ return icl::add(object, operand);
}
template <class Type>
@@ -194,7 +194,7 @@
typename Type::iterator prior_ = object.end();
ITL_const_FORALL(typename Type, it_, operand)
- prior_ = itl::add(object, prior_, *it_);
+ prior_ = icl::add(object, prior_, *it_);
return object;
}
@@ -211,7 +211,7 @@
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
operator |= (Type& object, const typename Type::value_type& operand)
{
- return itl::add(object, operand);
+ return icl::add(object, operand);
}
template <class Type>
@@ -277,7 +277,7 @@
iterator prior_ = object.end();
ITL_const_FORALL(typename Type, elem_, addend)
- itl::insert(object, prior_, *elem_);
+ icl::insert(object, prior_, *elem_);
return object;
}
@@ -305,7 +305,7 @@
erase(Type& object, const Type& erasure)
{
ITL_const_FORALL(typename Type, elem_, erasure)
- itl::erase(object, *elem_);
+ icl::erase(object, *elem_);
return object;
}
@@ -319,7 +319,7 @@
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
operator -= (Type& object, const typename Type::value_type& operand)
{
- return itl::subtract(object, operand);
+ return icl::subtract(object, operand);
}
template <class Type>
@@ -334,7 +334,7 @@
operator -= (Type& object, const Type& subtrahend)
{
ITL_const_FORALL(typename Type, it_, subtrahend)
- itl::subtract(object, *it_);
+ icl::subtract(object, *it_);
return object;
}
@@ -361,7 +361,7 @@
typedef typename Type::const_iterator const_iterator;
const_iterator it_ = object.find(operand);
if(it_ != object.end())
- itl::add(section, *it_);
+ icl::add(section, *it_);
}
//------------------------------------------------------------------------------
@@ -436,14 +436,14 @@
inline typename enable_if<is_associative_element_container<Type>, Type>::type
operator ^ (Type object, const typename Type::value_type& operand)
{
- return itl::flip(object, operand);
+ return icl::flip(object, operand);
}
template<class Type>
inline typename enable_if<is_associative_element_container<Type>, Type>::type
operator ^ (const typename Type::value_type& operand, Type object)
{
- return itl::flip(object, operand);
+ return icl::flip(object, operand);
}
template<class Type>
@@ -464,7 +464,7 @@
typename Type::iterator it_ = object.begin();
while(it_ != object.end())
if(pred(*it_))
- itl::erase(object, it_++);
+ icl::erase(object, it_++);
else ++it_;
return object;
}
@@ -476,7 +476,7 @@
typename Type::const_iterator it_ = src.begin();
while(it_ != src.end())
if(pred(*it_))
- itl::add(object, *it_++);
+ icl::add(object, *it_++);
return object;
}
@@ -485,7 +485,7 @@
inline typename enable_if<is_associative_element_container<Type>, Type>::type&
assign_if(const Predicate& pred, Type& object, const Type& src)
{
- itl::clear(object);
+ icl::clear(object);
return add_if(object, src, pred);
}
Modified: sandbox/itl/boost/itl/concept/element_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_map.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_map.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#include <boost/itl/detail/map_algo.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//NOTE: Some forward declarations are needed by some compilers.
@@ -52,7 +52,7 @@
typename enable_if<is_element_map<Type>, bool>::type
contains(const Type& super, const typename Type::element_type& value_pair)
{
- return itl::within(value_pair, super);
+ return icl::within(value_pair, super);
}
//==============================================================================
@@ -124,7 +124,7 @@
{
typedef typename Type::set_type set_type;
ITL_const_FORALL(typename set_type, elem_, erasure)
- itl::erase(object, *elem_);
+ icl::erase(object, *elem_);
return object;
}
@@ -149,7 +149,7 @@
typename enable_if<is_element_map<Type>, Type>::type&
subtract(Type& object, const typename Type::domain_type& key_value)
{
- return itl::erase(object, key_value);
+ return icl::erase(object, key_value);
}
//------------------------------------------------------------------------------
@@ -224,7 +224,7 @@
add_intersection(Type& section, const Type& object, const Type& operand)
{
ITL_const_FORALL(typename Type, it_, operand)
- itl::add_intersection(section, object, *it_);
+ icl::add_intersection(section, object, *it_);
}
//------------------------------------------------------------------------------
@@ -244,7 +244,7 @@
operator &=(Type& object, const typename Type::element_type& operand)
{
Type section;
- itl::add_intersection(section, object, operand);
+ icl::add_intersection(section, object, operand);
object.swap(section);
return object;
}
@@ -277,7 +277,7 @@
operator &=(Type& object, const Type& operand)
{
Type section;
- itl::add_intersection(section, object, operand);
+ icl::add_intersection(section, object, operand);
object.swap(section);
return object;
}
@@ -321,7 +321,7 @@
, bool>::type
intersects(const Type& object, const typename Type::domain_type& operand)
{
- return itl::contains(object, operand);
+ return icl::contains(object, operand);
}
template<class Type>
@@ -343,7 +343,7 @@
intersects(const Type& object, const typename Type::element_type& operand)
{
Type intersection;
- itl::add_intersection(intersection, object, operand);
+ icl::add_intersection(intersection, object, operand);
return !intersection.empty();
}
@@ -376,7 +376,7 @@
, Type>::type&
operator ^= (Type& object, const CoType&)
{
- itl::clear(object);
+ icl::clear(object);
return object;
}
@@ -398,7 +398,7 @@
operator ^= (Type& object, const Type& operand)
{
ITL_const_FORALL(typename Type, it_, operand)
- itl::flip(object, *it_);
+ icl::flip(object, *it_);
ITL_FORALL(typename Type, it2_, object)
it2_->second = identity_element<typename Type::codomain_type>::value();
@@ -413,7 +413,7 @@
, Type>::type&
operator ^= (Type& object, const typename Type::element_type& operand)
{
- return itl::flip(object, operand);
+ return icl::flip(object, operand);
}
template<class Type>
@@ -425,7 +425,7 @@
typedef typename Type::const_iterator const_iterator;
const_iterator it_ = operand.begin();
while(it_ != operand.end())
- itl::flip(object, *it_++);
+ icl::flip(object, *it_++);
return object;
}
@@ -456,7 +456,7 @@
absorb_identities(Type& object)
{
typedef typename Type::element_type element_type;
- return itl::erase_if(content_is_identity_element<element_type>(), object);
+ return icl::erase_if(content_is_identity_element<element_type>(), object);
}
template<class Type>
Modified: sandbox/itl/boost/itl/concept/element_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_set.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_set.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/detail/std_set.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
@@ -69,7 +69,7 @@
inline typename enable_if<is_element_set<Type>, bool>::type
intersects(const Type& object, const typename Type::domain_type& operand)
{
- return itl::contains(object, operand);
+ return icl::contains(object, operand);
}
template<class Type>
@@ -101,7 +101,7 @@
inline typename enable_if<is_element_set<Type>, Type>::type&
operator ^= (Type& object, const typename Type::element_tpye& operand)
{
- return itl::flip(object, operand);
+ return icl::flip(object, operand);
}
/** Symmetric subtract map \c x2 and \c *this.
@@ -113,7 +113,7 @@
typedef typename Type::const_iterator const_iterator;
const_iterator it_ = operand.begin();
while(it_ != operand.end())
- itl::flip(object, *it_++);
+ icl::flip(object, *it_++);
return object;
}
Modified: sandbox/itl/boost/itl/concept/element_set_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_set_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_set_value.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_element_container.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -31,7 +31,7 @@
#include <boost/itl/dynamic_interval_traits.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//==============================================================================
@@ -75,7 +75,7 @@
singleton(const typename interval_traits<Type>::domain_type& value)
{
//ASSERT: This always creates an interval with exactly one element
- return interval_traits<Type>::construct(value, itl::succ(value));
+ return interval_traits<Type>::construct(value, icl::succ(value));
}
template<class Type>
@@ -91,7 +91,7 @@
typedef typename interval_traits<Type>::domain_type domain_type;
BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value) ));
- return interval_traits<Type>::construct(itl::pred(value), value);
+ return interval_traits<Type>::construct(icl::pred(value), value);
}
template<class Type>
@@ -102,7 +102,7 @@
typedef typename interval_traits<Type>::domain_type domain_type;
BOOST_ASSERT((numeric_minimum<domain_type, is_numeric<domain_type>::value >::is_less_than(value)));
- return interval_traits<Type>::construct(itl::pred(value), itl::succ(value));
+ return interval_traits<Type>::construct(icl::pred(value), icl::succ(value));
}
template<class Type>
@@ -463,7 +463,7 @@
inline typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- BOOST_ASSERT(!(itl::is_empty(left) || itl::is_empty(right)));
+ BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
return domain_less_equal<Type>(upper(left), lower(right));
}
@@ -471,7 +471,7 @@
inline typename boost::enable_if<is_discrete_interval<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- BOOST_ASSERT(!(itl::is_empty(left) || itl::is_empty(right)));
+ BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
return domain_less<Type>(last(left), first(right));
}
@@ -480,7 +480,7 @@
enable_if<has_symmetric_bounds<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- BOOST_ASSERT(!(itl::is_empty(left) || itl::is_empty(right)));
+ BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
return domain_less<Type>(last(left), first(right));
}
@@ -488,7 +488,7 @@
inline typename boost::enable_if<is_continuous_interval<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- BOOST_ASSERT(!(itl::is_empty(left) || itl::is_empty(right)));
+ BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right)));
return domain_less <Type>(left.upper(), right.lower())
|| ( domain_equal<Type>(left.upper(), right.lower())
&& inner_bounds(left,right) != interval_bounds::open() );
@@ -510,31 +510,31 @@
inline typename boost::enable_if<is_interval<Type>, bool>::type
contains(const Type& super, const Type& sub)
{
- return itl::is_empty(sub) || non_empty::contains(super, sub);
+ return icl::is_empty(sub) || non_empty::contains(super, sub);
}
template<class Type>
typename boost::enable_if<is_discrete_static<Type>, bool>::type
contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
{
- return domain_less_equal<Type>(itl::first(super), element )
- && domain_less_equal<Type>( element, itl::last(super));
+ return domain_less_equal<Type>(icl::first(super), element )
+ && domain_less_equal<Type>( element, icl::last(super));
}
template<class Type>
typename boost::enable_if<is_continuous_left_open<Type>, bool>::type
contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
{
- return domain_less <Type>(itl::lower(super), element )
- && domain_less_equal<Type>( element, itl::upper(super));
+ return domain_less <Type>(icl::lower(super), element )
+ && domain_less_equal<Type>( element, icl::upper(super));
}
template<class Type>
typename boost::enable_if<is_continuous_right_open<Type>, bool>::type
contains(const Type& super, const typename interval_traits<Type>::domain_type& element)
{
- return domain_less_equal<Type>(itl::lower(super), element )
- && domain_less <Type>( element, itl::upper(super));
+ return domain_less_equal<Type>(icl::lower(super), element )
+ && domain_less <Type>( element, icl::upper(super));
}
template<class Type>
@@ -570,7 +570,7 @@
inline typename boost::enable_if<is_asymmetric_interval<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- return itl::is_empty(left) || itl::is_empty(right)
+ return icl::is_empty(left) || icl::is_empty(right)
|| domain_less_equal<Type>(upper(left), lower(right));
}
@@ -578,7 +578,7 @@
inline typename boost::enable_if<is_discrete_interval<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- return itl::is_empty(left) || itl::is_empty(right)
+ return icl::is_empty(left) || icl::is_empty(right)
|| domain_less<Type>(last(left), first(right));
}
@@ -587,7 +587,7 @@
enable_if<has_symmetric_bounds<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- return itl::is_empty(left) || itl::is_empty(right)
+ return icl::is_empty(left) || icl::is_empty(right)
|| domain_less<Type>(last(left), first(right));
}
@@ -595,7 +595,7 @@
inline typename boost::enable_if<is_continuous_interval<Type>, bool>::type
exclusive_less(const Type& left, const Type& right)
{
- return itl::is_empty(left) || itl::is_empty(right)
+ return icl::is_empty(left) || icl::is_empty(right)
|| domain_less<Type>(left.upper(), right.lower())
|| ( domain_equal<Type>(left.upper(), right.lower())
&& inner_bounds(left,right) != interval_bounds::open() );
@@ -772,7 +772,7 @@
typename boost::enable_if<is_interval<Type>, bool>::type
operator == (const Type& left, const Type& right)
{
- return (itl::is_empty(left) && itl::is_empty(right))
+ return (icl::is_empty(left) && icl::is_empty(right))
|| (lower_equal(left,right) && upper_equal(left,right));
}
@@ -788,8 +788,8 @@
typename boost::enable_if<is_interval<Type>, bool>::type
operator < (const Type& left, const Type& right)
{
- if(itl::is_empty(left))
- return !itl::is_empty(right);
+ if(icl::is_empty(left))
+ return !icl::is_empty(right);
else
return lower_less(left,right)
|| (lower_equal(left,right) && upper_less(left,right));
@@ -839,11 +839,11 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- if(itl::is_empty(object))
- return itl::identity_element<SizeT>::value();
+ if(icl::is_empty(object))
+ return icl::identity_element<SizeT>::value();
else if( object.bounds() == interval_bounds::closed()
&& domain_equal<Type>(lower(object), upper(object)))
- return itl::unit_element<SizeT>::value();
+ return icl::unit_element<SizeT>::value();
else
return infinity<SizeT>::value();
}
@@ -854,7 +854,7 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- return itl::is_empty(object) ? identity_element<SizeT>::value()
+ return icl::is_empty(object) ? identity_element<SizeT>::value()
: static_cast<SizeT>(last_next(object) - first(object));
}
@@ -864,8 +864,8 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- if(itl::is_empty(object))
- return itl::identity_element<SizeT>::value();
+ if(icl::is_empty(object))
+ return icl::identity_element<SizeT>::value();
else
return infinity<SizeT>::value();
}
@@ -876,7 +876,7 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- return itl::is_empty(object) ? identity_element<SizeT>::value()
+ return icl::is_empty(object) ? identity_element<SizeT>::value()
: static_cast<SizeT>(last_next(object) - first(object));
}
@@ -886,7 +886,7 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- return itl::is_empty(object) ? identity_element<SizeT>::value()
+ return icl::is_empty(object) ? identity_element<SizeT>::value()
: static_cast<SizeT>(last_next(object) - first(object));
}
@@ -908,7 +908,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? identity_element<DiffT>::value()
+ return icl::is_empty(object) ? identity_element<DiffT>::value()
: upper(object) - lower(object);
}
@@ -918,7 +918,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? identity_element<DiffT>::value()
+ return icl::is_empty(object) ? identity_element<DiffT>::value()
: last_next(object) - first(object);
}
@@ -928,7 +928,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? identity_element<DiffT>::value()
+ return icl::is_empty(object) ? identity_element<DiffT>::value()
: upper(object) - lower(object);
}
@@ -938,7 +938,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? identity_element<DiffT>::value()
+ return icl::is_empty(object) ? identity_element<DiffT>::value()
: last_next(object) - first(object);
}
@@ -953,9 +953,9 @@
{
typedef typename interval_traits<Type>::domain_compare domain_compare;
- if(itl::is_empty(right))
+ if(icl::is_empty(right))
return left;
- else if(itl::is_empty(left))
+ else if(icl::is_empty(left))
return right;
return
@@ -970,9 +970,9 @@
typename boost::enable_if<has_dynamic_bounds<Type>, Type>::type
hull(Type left, const Type& right)
{
- if(itl::is_empty(right))
+ if(icl::is_empty(right))
return left;
- else if(itl::is_empty(left))
+ else if(icl::is_empty(left))
return right;
return dynamic_interval_traits<Type>::construct_bounded
@@ -1099,14 +1099,14 @@
{
typedef typename interval_traits<Type>::domain_compare domain_compare;
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else
return
construct<Type>
(
- (std::max)(itl::lower(left), itl::lower(right), domain_compare()),
- (std::min)(itl::upper(left), itl::upper(right), domain_compare())
+ (std::max)(icl::lower(left), icl::lower(right), domain_compare()),
+ (std::min)(icl::upper(left), icl::upper(right), domain_compare())
);
}
@@ -1116,14 +1116,14 @@
{
typedef typename interval_traits<Type>::domain_compare domain_compare;
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else
return
construct<Type>
(
- (std::max)(itl::lower(left), itl::lower(right), domain_compare()),
- (std::min)(itl::upper(left), itl::upper(right), domain_compare())
+ (std::max)(icl::lower(left), icl::lower(right), domain_compare()),
+ (std::min)(icl::upper(left), icl::upper(right), domain_compare())
);
}
@@ -1131,7 +1131,7 @@
typename boost::enable_if<has_dynamic_bounds<Type>, Type>::type
operator & (Type left, const Type& right)
{
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else
return dynamic_interval_traits<Type>::construct_bounded
@@ -1147,7 +1147,7 @@
typename boost::enable_if<is_interval<Type>, bool>::type
intersects(const Type& left, const Type& right)
{
- return !( itl::is_empty(left) || itl::is_empty(right)
+ return !( icl::is_empty(left) || icl::is_empty(right)
|| exclusive_less(left,right) || exclusive_less(right,left));
}
@@ -1156,7 +1156,7 @@
typename boost::enable_if<is_interval<Type>, bool>::type
disjoint(const Type& left, const Type& right)
{
- return itl::is_empty(left) || itl::is_empty(right)
+ return icl::is_empty(left) || icl::is_empty(right)
|| exclusive_less(left,right) || exclusive_less(right,left);
}
@@ -1168,7 +1168,7 @@
typename boost::enable_if<is_asymmetric_interval<Type>, Type>::type
inner_complement(const Type& left, const Type& right)
{
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else if(exclusive_less(left, right))
return construct<Type>(upper(left), lower(right));
@@ -1182,7 +1182,7 @@
typename boost::enable_if<is_discrete_static_closed<Type>, Type>::type
inner_complement(const Type& left, const Type& right)
{
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else if(exclusive_less(left, right))
return construct<Type>(succ(upper(left)), pred(lower(right)));
@@ -1196,7 +1196,7 @@
typename boost::enable_if<is_discrete_static_open<Type>, Type>::type
inner_complement(const Type& left, const Type& right)
{
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else if(exclusive_less(left, right))
return construct<Type>(last(left), first(right));
@@ -1210,7 +1210,7 @@
typename boost::enable_if<has_dynamic_bounds<Type>, Type>::type
inner_complement(const Type& left, const Type& right)
{
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return identity_element<Type>::value();
else if(exclusive_less(left, right))
return right_subtract(left_subtract(hull(left, right), left), right);
@@ -1234,14 +1234,14 @@
{
typedef typename difference_type_of<interval_traits<Type> >::type difference_type;
- if(itl::is_empty(x1) || itl::is_empty(x2))
- return itl::identity_element<difference_type>::value();
+ if(icl::is_empty(x1) || icl::is_empty(x2))
+ return icl::identity_element<difference_type>::value();
else if(domain_less<Type>(last(x1), first(x2)))
return static_cast<difference_type>(pred(first(x2) - last(x1)));
else if(domain_less<Type>(last(x2), first(x1)))
return static_cast<difference_type>(pred(first(x1) - last(x2)));
else
- return itl::identity_element<difference_type>::value();
+ return icl::identity_element<difference_type>::value();
}
template<class Type>
@@ -1255,14 +1255,14 @@
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- if(itl::is_empty(x1) || itl::is_empty(x2))
- return itl::identity_element<DiffT>::value();
+ if(icl::is_empty(x1) || icl::is_empty(x2))
+ return icl::identity_element<DiffT>::value();
else if(domain_less<Type>(upper(x1), lower(x2)))
return x2.lower() - x1.upper();
else if(domain_less<Type>(upper(x2), lower(x1)))
return lower(x1) - upper(x2);
else
- return itl::identity_element<DiffT>::value();
+ return icl::identity_element<DiffT>::value();
}
//==============================================================================
@@ -1313,7 +1313,7 @@
std::basic_ostream<CharType, CharTraits> >::type&
operator << (std::basic_ostream<CharType, CharTraits> &stream, Type const& object)
{
- if(boost::itl::is_empty(object))
+ if(boost::icl::is_empty(object))
return stream << left_bracket<Type>(object) << right_bracket<Type>(object);
else
return stream << left_bracket<Type>(object)
@@ -1324,7 +1324,7 @@
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/concept/interval/base.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval/base.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval/base.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_combinable.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type>
@@ -19,7 +19,7 @@
{
typedef typename Type::interval_type interval_type;
typedef typename Type::segment_type segment_type;
- return segment_type(itl::singleton<interval_type>(element.key), element.data);
+ return segment_type(icl::singleton<interval_type>(element.key), element.data);
}
namespace segmental
Modified: sandbox/itl/boost/itl/concept/interval_associator.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_associator.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_associator.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/itl/detail/interval_map_algo.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
@@ -30,7 +30,7 @@
typename enable_if<is_interval_container<SuperT>, bool>::type
within(const SubT& sub, const SuperT& super)
{
- return itl::contains(super, sub);
+ return icl::contains(super, sub);
}
//==============================================================================
@@ -125,7 +125,7 @@
size_type size = identity_element<size_type>::value();
ITL_const_FORALL(typename Type, it, object)
- size += itl::cardinality(key_value<Type>(it));
+ size += icl::cardinality(key_value<Type>(it));
return size;
}
@@ -145,7 +145,7 @@
size_type interval_size;
ITL_const_FORALL(typename Type, it, object)
{
- interval_size = itl::cardinality(key_value<Type>(it));
+ interval_size = icl::cardinality(key_value<Type>(it));
if(interval_size == infinity<size_type>::value())
return interval_size;
else
@@ -158,7 +158,7 @@
inline typename enable_if<is_interval_container<Type>, typename Type::size_type>::type
size(const Type& object)
{
- return itl::cardinality(object);
+ return icl::cardinality(object);
}
template<class Type>
@@ -171,7 +171,7 @@
const_iterator it_ = object.begin();
while(it_ != object.end())
- length += itl::length(key_value<Type>(it_++));
+ length += icl::length(key_value<Type>(it_++));
return length;
}
@@ -179,7 +179,7 @@
typename enable_if<is_interval_container<Type>, std::size_t>::type
interval_count(const Type& object)
{
- return itl::iterative_size(object);
+ return icl::iterative_size(object);
}
//==============================================================================
@@ -191,7 +191,7 @@
hull(const ObjectT& object)
{
return
- itl::is_empty(object) ? identity_element<typename ObjectT::interval_type>::value()
+ icl::is_empty(object) ? identity_element<typename ObjectT::interval_type>::value()
: hull((key_value<ObjectT>(object.begin())), key_value<ObjectT>(object.rbegin()));
}
@@ -226,7 +226,7 @@
typename enable_if<is_intra_derivative<Type, OperandT>, Type>::type&
operator += (Type& object, const OperandT& operand)
{
- return itl::add(object, operand);
+ return icl::add(object, operand);
}
@@ -243,7 +243,7 @@
{
typename Type::iterator prior_ = object.end();
ITL_const_FORALL(typename OperandT, elem_, operand)
- prior_ = itl::add(object, prior_, *elem_);
+ prior_ = icl::add(object, prior_, *elem_);
return object;
}
@@ -400,7 +400,7 @@
{
typedef typename OperandT::const_iterator const_iterator;
- if(itl::is_empty(operand))
+ if(icl::is_empty(operand))
return object;
const_iterator common_lwb, common_upb;
@@ -409,7 +409,7 @@
const_iterator it_ = common_lwb;
while(it_ != common_upb)
- itl::erase(object, *it_++);
+ icl::erase(object, *it_++);
return object;
}
@@ -448,7 +448,7 @@
operator -=(Type& object, const OperandT& operand)
{
ITL_const_FORALL(typename OperandT, elem_, operand)
- itl::subtract(object, *elem_);
+ icl::subtract(object, *elem_);
return object;
}
@@ -460,7 +460,7 @@
typename enable_if<is_intra_derivative<Type, OperandT>, Type>::type&
operator -= (Type& object, const OperandT& operand)
{
- return itl::subtract(object, operand);
+ return icl::subtract(object, operand);
}
//------------------------------------------------------------------------------
@@ -470,7 +470,7 @@
typename enable_if<is_cross_derivative<Type, OperandT>, Type>::type&
operator -= (Type& object, const OperandT& operand)
{
- return itl::erase(object, operand);
+ return icl::erase(object, operand);
}
//------------------------------------------------------------------------------
@@ -519,7 +519,7 @@
const_iterator it_ = common_lwb;
while(it_ != common_upb)
- itl::add_intersection(section, object, key_value<OperandT>(it_++));
+ icl::add_intersection(section, object, key_value<OperandT>(it_++));
}
//------------------------------------------------------------------------------
@@ -577,7 +577,7 @@
bool>::type
intersects(const Type& left, const CoType& right)
{
- return itl::contains(left, right);
+ return icl::contains(left, right);
}
template<class Type, class CoType>
@@ -615,8 +615,8 @@
const_iterator it_ = right_common_lower_;
while(it_ != right_common_upper_)
{
- itl::add_intersection(intersection, left, *it_++);
- if(!itl::is_empty(intersection))
+ icl::add_intersection(intersection, left, *it_++);
+ if(!icl::is_empty(intersection))
return true;
}
return false;
@@ -629,7 +629,7 @@
typedef typename RightT::const_iterator const_iterator;
LeftT intersection;
- if(itl::is_empty(left) || itl::is_empty(right))
+ if(icl::is_empty(left) || icl::is_empty(right))
return false;
const_iterator right_common_lower_, right_common_upper_;
@@ -639,8 +639,8 @@
typename RightT::const_iterator it_ = right_common_lower_;
while(it_ != right_common_upper_)
{
- itl::add_intersection(intersection, left, key_value<RightT>(it_++));
- if(!itl::is_empty(intersection))
+ icl::add_intersection(intersection, left, key_value<RightT>(it_++));
+ if(!icl::is_empty(intersection))
return true;
}
@@ -653,7 +653,7 @@
bool>::type
intersects(const Type& left, const AssociateT& right)
{
- return itl::intersects(left, right);
+ return icl::intersects(left, right);
}
/** \b Returns true, if \c left and \c right have no common elements.
@@ -690,7 +690,7 @@
typename enable_if<is_intra_combinable<Type, OperandT>, Type>::type&
operator ^= (Type& object, const OperandT& operand)
{
- return itl::flip(object, operand);
+ return icl::flip(object, operand);
}
//------------------------------------------------------------------------------
@@ -700,7 +700,7 @@
typename enable_if<is_intra_derivative<Type, OperandT>, Type>::type&
operator ^= (Type& object, const OperandT& operand)
{
- return itl::flip(object, operand);
+ return icl::flip(object, operand);
}
//------------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/concept/interval_bounds.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_bounds.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_bounds.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/is_discrete.hpp>
#include <boost/itl/type_traits/is_numeric.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
inline interval_bounds left(interval_bounds x1)
@@ -87,10 +87,10 @@
if(is_left_closed(decl) && !is_left_closed(repr))
{
BOOST_ASSERT((numeric_minimum<Type, is_numeric<Type>::value >::is_less_than(low) ));
- return itl::pred(low);
+ return icl::pred(low);
}
else if(!is_left_closed(decl) && is_left_closed(repr))
- return itl::succ(low);
+ return icl::succ(low);
else
return low;
}
@@ -102,10 +102,10 @@
if(!is_right_closed(decl) && is_right_closed(repr))
{
BOOST_ASSERT((numeric_minimum<Type, is_numeric<Type>::value >::is_less_than(up) ));
- return itl::pred(up);
+ return icl::pred(up);
}
else if(is_right_closed(decl) && !is_right_closed(repr))
- return itl::succ(up);
+ return icl::succ(up);
else
return up;
}
@@ -157,7 +157,7 @@
{ return right_subtract_bounds(x1.bounds(), x2.bounds()); }
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/concept/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_map.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/itl/detail/interval_map_algo.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type>
@@ -48,7 +48,7 @@
typedef typename Type::const_iterator const_iterator;
interval_type sub_interval = sub_segment.first;
- if(itl::is_empty(sub_interval))
+ if(icl::is_empty(sub_interval))
return true;
std::pair<const_iterator, const_iterator> exterior = super.equal_range(sub_interval);
@@ -61,7 +61,7 @@
return false;
return
- itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ icl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
&& Interval_Map::is_joinable(super, exterior.first, last_overlap);
}
@@ -106,7 +106,7 @@
{
typedef typename Type::const_iterator const_iterator;
- if(itl::is_empty(sub_interval))
+ if(icl::is_empty(sub_interval))
return true;
std::pair<const_iterator, const_iterator> exterior = super.equal_range(sub_interval);
@@ -116,7 +116,7 @@
const_iterator last_overlap = prior(exterior.second);
return
- itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ icl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
&& Interval_Set::is_joinable(super, exterior.first, last_overlap);
}
@@ -146,7 +146,7 @@
typename enable_if<is_interval_map<Type>, Type>::type&
add(Type& object, const typename Type::element_type& operand)
{
- return itl::add(object, make_segment<Type>(operand));
+ return icl::add(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -177,7 +177,7 @@
inline typename enable_if<is_interval_map<Type>, Type>::type&
insert(Type& object, const typename Type::element_type& operand)
{
- return itl::insert(object, make_segment<Type>(operand));
+ return icl::insert(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -210,7 +210,7 @@
erase(Type& object, const typename Type::domain_type& operand)
{
typedef typename Type::interval_type interval_type;
- return itl::erase(object, itl::singleton<interval_type>(operand));
+ return icl::erase(object, icl::singleton<interval_type>(operand));
}
//------------------------------------------------------------------------------
@@ -227,7 +227,7 @@
inline typename enable_if<is_interval_map<Type>, Type>::type&
erase(Type& object, const typename Type::element_type& operand)
{
- return itl::erase(object, make_segment<Type>(operand));
+ return icl::erase(object, make_segment<Type>(operand));
}
//==============================================================================
@@ -247,7 +247,7 @@
typename enable_if<is_interval_map<Type>, Type>::type&
subtract(Type& object, const typename Type::element_type& operand)
{
- return itl::subtract(object, make_segment<Type>(operand));
+ return icl::subtract(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -277,15 +277,15 @@
typename enable_if<is_interval_map<Type>, Type>::type&
set_at(Type& object, const typename Type::segment_type& operand)
{
- itl::erase(object, operand.first);
- return itl::insert(object, operand);
+ icl::erase(object, operand.first);
+ return icl::insert(object, operand);
}
template<class Type>
typename enable_if<is_interval_map<Type>, Type>::type&
set_at(Type& object, const typename Type::element_type& operand)
{
- return itl::set_at(object, make_segment<Type>(operand));
+ return icl::set_at(object, make_segment<Type>(operand));
}
//==============================================================================
@@ -380,7 +380,7 @@
typedef typename Type::const_iterator const_iterator;
typedef typename Type::iterator iterator;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return;
std::pair<const_iterator, const_iterator> exterior
@@ -392,7 +392,7 @@
for(const_iterator it_=exterior.first; it_ != exterior.second; it_++)
{
interval_type common_interval = it_->first & inter_val;
- if(!itl::is_empty(common_interval))
+ if(!icl::is_empty(common_interval))
prior_ = add(section, prior_,
value_type(common_interval, it_->second) );
}
@@ -404,7 +404,7 @@
{
typedef typename KeySetT::const_iterator const_iterator;
- if(itl::is_empty(key_set))
+ if(icl::is_empty(key_set))
return;
const_iterator common_lwb, common_upb;
@@ -437,8 +437,8 @@
intersects(const Type& object, const OperandT& operand)
{
Type intersection;
- itl::add_intersection(intersection, left, operand);
- return !itl::is_empty(intersection);
+ icl::add_intersection(intersection, left, operand);
+ return !icl::is_empty(intersection);
}
template<class Type, class OperandT>
@@ -447,7 +447,7 @@
bool>::type
intersects(const Type& object, const OperandT& operand)
{
- return itl::intersects(object, make_segment<Type>(operand));
+ return icl::intersects(object, make_segment<Type>(operand));
}
//==============================================================================
@@ -467,7 +467,7 @@
inline typename enable_if<is_interval_map<Type>, Type>::type&
flip(Type& object, const typename Type::element_type& operand)
{
- return itl::flip(object, make_segment<Type>(operand));
+ return icl::flip(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -509,7 +509,7 @@
it_->second = identity_element<codomain_type>::value();
if(mpl::not_<is_interval_splitter<Type> >::value)
- itl::join(object);
+ icl::join(object);
return object;
}
@@ -541,13 +541,13 @@
// All elements of operand left of the common range are added
while(it_ != common_lwb)
- itl::add(object, *it_++);
+ icl::add(object, *it_++);
// All elements of operand in the common range are symmetrically subtracted
while(it_ != common_upb)
- itl::flip(object, *it_++);
+ icl::flip(object, *it_++);
// All elements of operand right of the common range are added
while(it_ != operand.end())
- itl::add(object, *it_++);
+ icl::add(object, *it_++);
return object;
}
@@ -589,7 +589,7 @@
typename MapT::const_iterator it_ = src.begin();
while(it_ != src.end())
if(pred(*it_))
- itl::add(object, *it_++);
+ icl::add(object, *it_++);
return object;
}
@@ -598,7 +598,7 @@
inline typename enable_if<is_interval_map<MapT>, MapT>::type&
assign_if(const Predicate& pred, MapT& object, const MapT& src)
{
- itl::clear(object);
+ icl::clear(object);
return add_if(object, src, pred);
}
@@ -620,7 +620,7 @@
absorb_identities(Type& object)
{
typedef typename Type::segment_type segment_type;
- return itl::erase_if(content_is_identity_element<segment_type>(), object);
+ return icl::erase_if(content_is_identity_element<segment_type>(), object);
}
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_set.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/detail/interval_set_algo.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
@@ -34,7 +34,7 @@
contains(const Type& super, const typename Type::segment_type& inter_val)
{
typedef typename Type::const_iterator const_iterator;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return true;
std::pair<const_iterator, const_iterator> exterior
@@ -45,7 +45,7 @@
const_iterator last_overlap = cyclic_prior(super, exterior.second);
return
- itl::contains(hull(*(exterior.first), *last_overlap), inter_val)
+ icl::contains(hull(*(exterior.first), *last_overlap), inter_val)
&& Interval_Set::is_joinable(super, exterior.first, last_overlap);
}
@@ -75,7 +75,7 @@
add(Type& object, const typename Type::element_type& operand)
{
typedef typename Type::segment_type segment_type;
- return itl::add(object, itl::singleton<segment_type>(operand));
+ return icl::add(object, icl::singleton<segment_type>(operand));
}
//------------------------------------------------------------------------------
@@ -99,14 +99,14 @@
typename enable_if<is_interval_set<Type>, Type>::type&
insert(Type& object, const typename Type::segment_type& operand)
{
- return itl::add(object, operand);
+ return icl::add(object, operand);
}
template<class Type>
typename enable_if<is_interval_set<Type>, Type>::type&
insert(Type& object, const typename Type::element_type& operand)
{
- return itl::add(object, operand);
+ return icl::add(object, operand);
}
//------------------------------------------------------------------------------
@@ -117,7 +117,7 @@
insert(Type& object, const typename Type::iterator prior,
const typename Type::segment_type& operand)
{
- return itl::add(object, prior, operand);
+ return icl::add(object, prior, operand);
}
//==============================================================================
@@ -138,7 +138,7 @@
subtract(Type& object, const typename Type::element_type& operand)
{
typedef typename Type::segment_type segment_type;
- return itl::subtract(object, itl::singleton<segment_type>(operand));
+ return icl::subtract(object, icl::singleton<segment_type>(operand));
}
//==============================================================================
@@ -151,14 +151,14 @@
typename enable_if<is_interval_set<Type>, Type>::type&
erase(Type& object, const typename Type::segment_type& minuend)
{
- return itl::subtract(object, minuend);
+ return icl::subtract(object, minuend);
}
template<class Type>
typename enable_if<is_interval_set<Type>, Type>::type&
erase(Type& object, const typename Type::element_type& minuend)
{
- return itl::subtract(object, minuend);
+ return icl::subtract(object, minuend);
}
//==============================================================================
@@ -175,7 +175,7 @@
typedef typename Type::const_iterator const_iterator;
const_iterator found = object.find(operand);
if(found != object.end())
- itl::add(section, operand);
+ icl::add(section, operand);
}
@@ -188,7 +188,7 @@
typedef typename Type::iterator iterator;
typedef typename Type::interval_type interval_type;
- if(itl::is_empty(segment))
+ if(icl::is_empty(segment))
return;
std::pair<const_iterator, const_iterator> exterior
@@ -200,7 +200,7 @@
for(const_iterator it_=exterior.first; it_ != exterior.second; it_++)
{
interval_type common_interval = key_value<Type>(it_) & segment;
- if(!itl::is_empty(common_interval))
+ if(!icl::is_empty(common_interval))
prior_ = section.insert(prior_, common_interval);
}
}
@@ -215,7 +215,7 @@
typename enable_if<is_interval_set<Type>, Type>::type&
flip(Type& object, const typename Type::element_type& operand)
{
- if(itl::contains(object, operand))
+ if(icl::contains(object, operand))
return object -= operand;
else
return object += operand;
@@ -246,8 +246,8 @@
// [b ... : covered
//[a b) : left_over
left_over = right_subtract(span, covered);
- itl::subtract(object, span & covered); //That which is common shall be subtracted
- itl::add(object, left_over); //That which is not shall be added
+ icl::subtract(object, span & covered); //That which is common shall be subtracted
+ icl::add(object, left_over); //That which is not shall be added
//... d) : span
//... c) : covered
@@ -256,7 +256,7 @@
}
//If span is not empty here, it_ is not in the set so it_ shall be added
- itl::add(object, span);
+ icl::add(object, span);
return object;
}
@@ -279,13 +279,13 @@
// All elements of operand left of the common range are added
while(it_ != common_lwb)
- itl::add(object, *it_++);
+ icl::add(object, *it_++);
// All elements of operand in the common range are symmertrically subtracted
while(it_ != common_upb)
- itl::flip(object, *it_++);
+ icl::flip(object, *it_++);
// All elements of operand right of the common range are added
while(it_ != operand.end())
- itl::add(object, *it_++);
+ icl::add(object, *it_++);
return object;
}
Modified: sandbox/itl/boost/itl/concept/interval_set_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_set_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_set_value.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/is_interval_container.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
@@ -23,7 +23,7 @@
co_value(Iterator value_)
{
typedef typename Type::codomain_type codomain_type;
- return itl::is_empty(*value_)? codomain_type() : (*value_).lower();
+ return icl::is_empty(*value_)? codomain_type() : (*value_).lower();
}
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/concept/map_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/map_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/map_value.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_map.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/set_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/set_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/set_value.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_set.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//==============================================================================
Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#include <boost/itl/interval_bounds.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class DomainT,
@@ -43,7 +43,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_continuous<DomainT>::value));
}
//NOTE: Compiler generated copy constructor is used
@@ -54,7 +54,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_continuous<DomainT>::value));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
@@ -65,7 +65,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_continuous<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_continuous<DomainT>::value));
}
domain_type lower()const { return _lwb; }
@@ -88,12 +88,12 @@
//=T continuous_interval -> concept interval
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::continuous_interval<DomainT, Compare> >
+struct interval_traits< icl::continuous_interval<DomainT, Compare> >
{
typedef interval_traits type;
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::continuous_interval<DomainT, Compare> interval_type;
+ typedef icl::continuous_interval<DomainT, Compare> interval_type;
static interval_type construct(const domain_type& lo, const domain_type& up)
{
@@ -109,27 +109,27 @@
//=T continuous_interval -> concept dynamic_interval
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct dynamic_interval_traits<boost::itl::continuous_interval<DomainT,Compare> >
+struct dynamic_interval_traits<boost::icl::continuous_interval<DomainT,Compare> >
{
typedef dynamic_interval_traits type;
- typedef boost::itl::continuous_interval<DomainT,Compare> interval_type;
+ typedef boost::icl::continuous_interval<DomainT,Compare> interval_type;
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
static interval_type construct(const domain_type lo, const domain_type up, interval_bounds bounds)
{
- return itl::continuous_interval<DomainT,Compare>(lo, up, bounds,
- static_cast<itl::continuous_interval<DomainT,Compare>* >(0) );
+ return icl::continuous_interval<DomainT,Compare>(lo, up, bounds,
+ static_cast<icl::continuous_interval<DomainT,Compare>* >(0) );
}
static interval_type construct_bounded(const bounded_value<DomainT>& lo,
const bounded_value<DomainT>& up)
{
- return itl::continuous_interval<DomainT,Compare>
+ return icl::continuous_interval<DomainT,Compare>
(
lo.value(), up.value(),
lo.bound().left() | up.bound().right(),
- static_cast<itl::continuous_interval<DomainT,Compare>* >(0)
+ static_cast<icl::continuous_interval<DomainT,Compare>* >(0)
);
}
};
@@ -152,20 +152,20 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::continuous_interval<DomainT,Compare> >
+struct type_to_string<icl::continuous_interval<DomainT,Compare> >
{
static std::string apply()
{ return "cI<"+ type_to_string<DomainT>::apply() +">"; }
};
template<class DomainT>
-struct value_size<itl::continuous_interval<DomainT> >
+struct value_size<icl::continuous_interval<DomainT> >
{
- static std::size_t apply(const itl::continuous_interval<DomainT>& value)
+ static std::size_t apply(const icl::continuous_interval<DomainT>& value)
{ return 2; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/associated_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/associated_value.hpp (original)
+++ sandbox/itl/boost/itl/detail/associated_value.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/mpl/not.hpp>
#include <boost/mpl/and.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class Type, class CoType>
@@ -37,7 +37,7 @@
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/concept_check.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/concept_check.hpp (original)
+++ sandbox/itl/boost/itl/detail/concept_check.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/concept_check.hpp>
#include <boost/concept/detail/concept_def.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
BOOST_concept(EqualComparable,(Type))
Modified: sandbox/itl/boost/itl/detail/design_config.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/design_config.hpp (original)
+++ sandbox/itl/boost/itl/detail/design_config.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -39,8 +39,8 @@
#endif
#ifdef ITL_CONCEPT_ORIENTED //CL
-# define ITL_FUN_CALL(func, arg) itl::func(arg)
-# define ITL_FUN_REN(func_obj, func_conc, arg) itl::func_conc(arg)
+# define ITL_FUN_CALL(func, arg) icl::func(arg)
+# define ITL_FUN_REN(func_obj, func_conc, arg) icl::func_conc(arg)
#else //ITL_OBJECT_ORIENTED
# define ITL_FUN_CALL(func,arg) arg.func()
# define ITL_FUN_REN(func_obj, func_conc, arg) arg.func_obj()
@@ -142,9 +142,9 @@
//------------------------------------------------------------------------------
#ifdef ITL_NEW_INTERVAL_IMPL
-# define ITL_INTERVAL_DEFAULT boost::itl::interval_type_default
+# define ITL_INTERVAL_DEFAULT boost::icl::interval_type_default
#else
-# define ITL_INTERVAL_DEFAULT boost::itl::interval
+# define ITL_INTERVAL_DEFAULT boost::icl::interval
#endif
//------------------------------------------------------------------------------
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/type_traits/identity_element.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace Interval_Set
@@ -204,7 +204,7 @@
} // namespace Interval_Set
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_iterator.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_iterator.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/config/warning_disable.hpp>
#include <boost/itl/detail/mapped_reference.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//------------------------------------------------------------------------------
@@ -63,9 +63,9 @@
};
template<class BaseIteratorT>
-struct is_reverse<itl::element_iterator<BaseIteratorT> >
+struct is_reverse<icl::element_iterator<BaseIteratorT> >
{
- typedef is_reverse<itl::element_iterator<BaseIteratorT> > type;
+ typedef is_reverse<icl::element_iterator<BaseIteratorT> > type;
BOOST_STATIC_CONSTANT(bool, value = is_reverse<BaseIteratorT>::value);
};
@@ -201,13 +201,13 @@
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->last(); }
- static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(*leaper);}
+ static domain_difference_type length(const SegmentIteratorT& leaper){ return icl::length(*leaper);}
static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
const domain_difference_type& sneaker)
{
- inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(*leaper) - sneaker
- : itl::first(*leaper) + sneaker;
+ inter_pos = is_reverse<SegmentIteratorT>::value ? icl::last(*leaper) - sneaker
+ : icl::first(*leaper) + sneaker;
return inter_pos;
}
};
@@ -226,13 +226,13 @@
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); }
- static domain_difference_type length(const SegmentIteratorT& leaper){ return itl::length(leaper->first);}
+ static domain_difference_type length(const SegmentIteratorT& leaper){ return icl::length(leaper->first);}
static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper,
const domain_difference_type& sneaker)
{
- inter_pos = is_reverse<SegmentIteratorT>::value ? itl::last(leaper->first) - sneaker
- : itl::first(leaper->first) + sneaker;
+ inter_pos = is_reverse<SegmentIteratorT>::value ? icl::last(leaper->first) - sneaker
+ : icl::first(leaper->first) + sneaker;
return transit_type(inter_pos, leaper->second);
}
};
@@ -326,7 +326,7 @@
// _saltator->first.first() <= _inter_pos <= _saltator->first.last()
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_DETAIL_ELEMENT_ITERATOR_HPP_JOFA_091104
Modified: sandbox/itl/boost/itl/detail/exclusive_less_than.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/exclusive_less_than.hpp (original)
+++ sandbox/itl/boost/itl/detail/exclusive_less_than.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/concept/interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
/// Comparison functor on intervals implementing an overlap free less
@@ -20,7 +20,7 @@
/** Operator <tt>operator()</tt> implements a strict weak ordering on intervals. */
bool operator()(const IntervalT& left, const IntervalT& right)const
{
- return itl::non_empty::exclusive_less(left, right);
+ return icl::non_empty::exclusive_less(left, right);
}
};
Modified: sandbox/itl/boost/itl/detail/interval_map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_map_algo.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#include <boost/itl/detail/element_comparer.hpp>
#include <boost/itl/detail/interval_subset_comparer.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
@@ -40,12 +40,12 @@
++next_;
const typename IntervalMapT::codomain_type& co_value
- = itl::co_value<IntervalMapT>(first);
+ = icl::co_value<IntervalMapT>(first);
while(it_ != past)
{
- if(itl::co_value<IntervalMapT>(next_) != co_value)
+ if(icl::co_value<IntervalMapT>(next_) != co_value)
return false;
- if(!itl::touches(key_value<IntervalMapT>(it_++),
+ if(!icl::touches(key_value<IntervalMapT>(it_++),
key_value<IntervalMapT>(next_++)))
return false;
}
@@ -81,7 +81,7 @@
const typename IntervalMapT::interval_type& sub_interval)
{
typedef typename IntervalMapT::const_iterator const_iterator;
- if(itl::is_empty(sub_interval))
+ if(icl::is_empty(sub_interval))
return true;
std::pair<const_iterator, const_iterator> exterior = container.equal_range(sub_interval);
@@ -91,7 +91,7 @@
const_iterator last_overlap = prior(exterior.second);
return
- itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ icl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
&& Interval_Set::is_joinable(container, exterior.first, last_overlap);
}
@@ -139,7 +139,7 @@
{
typedef typename IntervalMapT::const_iterator const_iterator;
typename IntervalMapT::interval_type sub_interval = sub_segment.first;
- if(itl::is_empty(sub_interval))
+ if(icl::is_empty(sub_interval))
return true;
std::pair<const_iterator, const_iterator> exterior = container.equal_range(sub_interval);
@@ -152,7 +152,7 @@
return false;
return
- itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ icl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
&& Interval_Map::is_joinable(container, exterior.first, last_overlap);
}
@@ -165,7 +165,7 @@
} // namespace Interval_Map
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/interval_morphism.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_morphism.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_morphism.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/concept/set_value.hpp>
#include <boost/itl/concept/map_value.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace segmental
{
@@ -23,11 +23,11 @@
{
ITL_const_FORALL(typename IntervalContainerT, itv_, src)
{
- const typename IntervalContainerT::key_type& itv = itl::key_value<IntervalContainerT>(itv_);
- typename IntervalContainerT::codomain_type coval = itl::co_value<IntervalContainerT>(itv_);
+ const typename IntervalContainerT::key_type& itv = icl::key_value<IntervalContainerT>(itv_);
+ typename IntervalContainerT::codomain_type coval = icl::co_value<IntervalContainerT>(itv_);
for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element)
- insert(result, itl::make_value<ElementContainerT>(element, coval));
+ insert(result, icl::make_value<ElementContainerT>(element, coval));
}
}
@@ -40,7 +40,7 @@
const typename ElementContainerT::key_type& key = key_value<ElementContainerT>(element_);
const typename ElementContainerT::data_type& data = co_value<ElementContainerT>(element_);
- result += itl::make_value<IntervalContainerT>(key_type(key), data);
+ result += icl::make_value<IntervalContainerT>(key_type(key), data);
}
}
@@ -67,7 +67,7 @@
{
void operator()(JointType& joint, SplitType& split)
{
- itl::join(split);
+ icl::join(split);
ITL_FORALL(typename SplitType, split_, split)
joint.insert(*split_);
}
@@ -78,7 +78,7 @@
{
void operator()(AbsorberType& absorber, EnricherType& enricher)
{
- itl::absorb_identities(enricher);
+ icl::absorb_identities(enricher);
ITL_FORALL(typename EnricherType, enricher_, enricher)
absorber.insert(*enricher_);
}
Modified: sandbox/itl/boost/itl/detail/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_set_algo.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -21,7 +21,7 @@
#include <boost/itl/detail/interval_subset_comparer.hpp>
#include <boost/itl/detail/associated_value.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace Interval_Set
@@ -80,7 +80,7 @@
++next_;
while(next_ != container.end() && it_ != past)
- if(!itl::touches(key_value<IntervalContainerT>(it_++),
+ if(!icl::touches(key_value<IntervalContainerT>(it_++),
key_value<IntervalContainerT>(next_++)))
return false;
@@ -209,7 +209,7 @@
++next_;
while(next_ != container.end() && it_ != past)
- if(!itl::touches(key_value<IntervalContainerT>(it_++),
+ if(!icl::touches(key_value<IntervalContainerT>(it_++),
key_value<IntervalContainerT>(next_++)))
return false;
@@ -474,14 +474,14 @@
// only for the first there can be a left_resid: a part of *first_ left of inter_val
interval_type left_resid = right_subtract(key_value<Type>(first_), inter_val);
- if(!itl::is_empty(left_resid))
+ if(!icl::is_empty(left_resid))
{ // [------------ . . .
// [left_resid---first_ --- . . .
iterator prior_ = cyclic_prior(object, first_);
const_cast<interval_type&>(key_value<Type>(first_))
= left_subtract(key_value<Type>(first_), left_resid);
//NOTE: Only splitting
- object._insert(prior_, itl::make_value<Type>(left_resid, co_value<Type>(first_)));
+ object._insert(prior_, icl::make_value<Type>(left_resid, co_value<Type>(first_)));
}
//POST:
@@ -496,7 +496,7 @@
{
typedef typename Type::interval_type interval_type;
interval_type lead_gap = right_subtract(inter_val, *it_);
- if(!itl::is_empty(lead_gap))
+ if(!icl::is_empty(lead_gap))
// [lead_gap--- . . .
// [prior_) [-- it_ ...
object._insert(prior(it_), lead_gap);
@@ -535,13 +535,13 @@
interval_type cur_itv = *it_;
interval_type lead_gap = right_subtract(inter_val, cur_itv);
- if(!itl::is_empty(lead_gap))
+ if(!icl::is_empty(lead_gap))
// [lead_gap--- . . .
// [prior_) [-- it_ ...
object._insert(prior_, lead_gap);
interval_type end_gap = left_subtract(inter_val, cur_itv);
- if(!itl::is_empty(end_gap))
+ if(!icl::is_empty(end_gap))
// [---------------end_gap)
// [-- it_ --)
it_ = object._insert(it_, end_gap);
@@ -550,7 +550,7 @@
// only for the last there can be a right_resid: a part of *it_ right of addend
interval_type right_resid = left_subtract(cur_itv, inter_val);
- if(!itl::is_empty(right_resid))
+ if(!icl::is_empty(right_resid))
{
// [--------------)
// [-- it_ --right_resid)
@@ -572,7 +572,7 @@
typedef typename Type::iterator iterator;
typedef typename on_style<Type, Type::fineness>::type on_style_;
- if(itl::is_empty(addend))
+ if(icl::is_empty(addend))
return object.end();
std::pair<iterator,bool> insertion = object._insert(addend);
@@ -593,7 +593,7 @@
typedef typename Type::iterator iterator;
typedef typename on_style<Type, Type::fineness>::type on_style_;
- if(itl::is_empty(addend))
+ if(icl::is_empty(addend))
return prior_;
iterator insertion = object._insert(prior_, addend);
@@ -615,7 +615,7 @@
typedef typename Type::interval_type interval_type;
typedef typename Type::value_type value_type;
- if(itl::is_empty(minuend)) return;
+ if(icl::is_empty(minuend)) return;
std::pair<iterator, iterator> exterior = object.equal_range(minuend);
if(exterior.first == exterior.second) return;
@@ -631,17 +631,17 @@
object.erase(first_, end_);
- if(!itl::is_empty(leftResid))
+ if(!icl::is_empty(leftResid))
object._insert(leftResid);
- if(!itl::is_empty(rightResid))
+ if(!icl::is_empty(rightResid))
object._insert(rightResid);
}
} // namespace Interval_Set
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/itl/type_traits/is_set.hpp>
#include <boost/itl/concept/interval_set_value.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
#ifdef BOOST_MSVC
@@ -34,8 +34,8 @@
{
static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
{
- return inclusion_compare( itl::co_value<LeftT>(left_),
- itl::co_value<RightT>(right_));
+ return inclusion_compare( icl::co_value<LeftT>(left_),
+ icl::co_value<RightT>(right_));
}
};
@@ -44,7 +44,7 @@
{
static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
{
- if(itl::co_value<LeftT>(left_) == itl::co_value<RightT>(right_))
+ if(icl::co_value<LeftT>(left_) == icl::co_value<RightT>(right_))
return inclusion::equal;
else
return inclusion::unrelated;
@@ -362,7 +362,7 @@
#pragma warning(pop)
#endif
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/map_algo.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
#pragma warning(disable:4127) // conditional expression is constant
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace Map
{
@@ -34,7 +34,7 @@
co_iterator right_ = right_common_lower_;
while(right_ != right_common_upper_)
- if(itl::intersects(left, key_value<CoObjectT>(right_++)))
+ if(icl::intersects(left, key_value<CoObjectT>(right_++)))
return true;
return false;
Modified: sandbox/itl/boost/itl/detail/mapped_reference.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/mapped_reference.hpp (original)
+++ sandbox/itl/boost/itl/detail/mapped_reference.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/mpl/if.hpp>
#include <boost/itl/type_traits/is_concept_equivalent.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class FirstT, class SecondT> class mapped_reference;
@@ -187,6 +187,6 @@
inline mapped_reference<FirstT, SecondT> make_mapped_reference(const FirstT& left, SecondT& right)
{ return mapped_reference<FirstT, SecondT>(left, right); }
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_DETAIL_MAPPED_REFERENCE_HPP_JOFA_091108
Modified: sandbox/itl/boost/itl/detail/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/notate.hpp (original)
+++ sandbox/itl/boost/itl/detail/notate.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -24,10 +24,10 @@
// Plain old array iteration (assuming member function VecT::size()!)
#define ITL_FORALL_VEC(idx, vec) for(int idx=0; idx<vec.size(); idx++)
-namespace boost{namespace itl
+namespace boost{namespace icl
{
const int UNDEFINED_INDEX = -1;
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_DETAIL_NOTATE_HPP_JOFA_990119
Modified: sandbox/itl/boost/itl/detail/on_absorbtion.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/on_absorbtion.hpp (original)
+++ sandbox/itl/boost/itl/detail/on_absorbtion.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_ON_ABSORBTION_HPP_JOFA_100915
#define BOOST_ITL_TYPE_TRAITS_ON_ABSORBTION_HPP_JOFA_100915
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type, class Combiner, bool absorbs_identities>
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#ifndef BOOST_ITL_RELATION_STATE_HPP_JOFA_090214
#define BOOST_ITL_RELATION_STATE_HPP_JOFA_090214
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace comparison
{
@@ -30,7 +30,7 @@
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_RELATION_STATE_HPP_JOFA_090214
Modified: sandbox/itl/boost/itl/detail/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/set_algo.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -21,7 +21,7 @@
#include <boost/itl/concept/map_value.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace Set
@@ -39,7 +39,7 @@
lwb = x1.end();
upb = x1.end();
- if(itl::is_empty(x1) || itl::is_empty(x2))
+ if(icl::is_empty(x1) || icl::is_empty(x2))
return false;
IteratorT x1_fst_ = x1.begin();
@@ -49,16 +49,16 @@
ConstObject_iterator x2_lst_ = x2.end(); x2_lst_--;
typename ObjectT::key_compare key_less;
- if(key_less(itl::key_value< PureObjectT>(x1_lst_),
- itl::key_value<ConstObjectT>(x2_fst_))) // {x1} {x2}
+ if(key_less(icl::key_value< PureObjectT>(x1_lst_),
+ icl::key_value<ConstObjectT>(x2_fst_))) // {x1} {x2}
return false;
- if(key_less(itl::key_value<ConstObjectT>(x2_lst_),
- itl::key_value< PureObjectT>(x1_fst_))) // {x2} {x1}
+ if(key_less(icl::key_value<ConstObjectT>(x2_lst_),
+ icl::key_value< PureObjectT>(x1_fst_))) // {x2} {x1}
return false;
// We do have a common range
- lwb = x1.lower_bound(itl::key_value<ConstObjectT>(x2_fst_));
- upb = x1.upper_bound(itl::key_value<ConstObjectT>(x2_lst_));
+ lwb = x1.lower_bound(icl::key_value<ConstObjectT>(x2_fst_));
+ upb = x1.upper_bound(icl::key_value<ConstObjectT>(x2_lst_));
return true;
}
@@ -70,8 +70,8 @@
inline bool within(const SetType& sub, const SetType& super)
{
if(&super == &sub) return true;
- if(itl::is_empty(sub)) return true;
- if(itl::is_empty(super)) return false;
+ if(icl::is_empty(sub)) return true;
+ if(icl::is_empty(super)) return false;
typename SetType::const_iterator common_lwb_, common_upb_;
if(!common_range(common_lwb_, common_upb_, sub, super))
@@ -129,7 +129,7 @@
} // namespace Set
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/detail/std_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/std_set.hpp (original)
+++ sandbox/itl/boost/itl/detail/std_set.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/is_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class Type>
@@ -32,7 +32,7 @@
{ return "set<"+ type_to_string<Type>::apply() +">"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_DETAIL_STD_SET_HPP_JOFA_101007
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
#include <boost/itl/concept/interval_set_value.hpp>
#include <boost/itl/concept/map_value.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
#ifdef BOOST_MSVC
@@ -253,7 +253,7 @@
#pragma warning(pop)
#endif
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/discrete_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
#include <boost/itl/interval_bounds.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class DomainT,
@@ -42,7 +42,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
}
//NOTE: Compiler generated copy constructor is used
@@ -53,7 +53,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
@@ -64,7 +64,7 @@
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
}
domain_type lower()const { return _lwb; }
@@ -86,12 +86,12 @@
//=T discrete_interval -> concept intervals
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::discrete_interval<DomainT, Compare> >
+struct interval_traits< icl::discrete_interval<DomainT, Compare> >
{
typedef interval_traits type;
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::discrete_interval<DomainT, Compare> interval_type;
+ typedef icl::discrete_interval<DomainT, Compare> interval_type;
static interval_type construct(const domain_type& lo, const domain_type& up)
{
@@ -106,10 +106,10 @@
//=T discrete_interval -> concept dynamic_interval_traits
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct dynamic_interval_traits<boost::itl::discrete_interval<DomainT,Compare> >
+struct dynamic_interval_traits<boost::icl::discrete_interval<DomainT,Compare> >
{
typedef dynamic_interval_traits type;
- typedef boost::itl::discrete_interval<DomainT,Compare> interval_type;
+ typedef boost::icl::discrete_interval<DomainT,Compare> interval_type;
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
@@ -148,20 +148,20 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::discrete_interval<DomainT,Compare> >
+struct type_to_string<icl::discrete_interval<DomainT,Compare> >
{
static std::string apply()
{ return "dI<"+ type_to_string<DomainT>::apply() +">"; }
};
template<class DomainT>
-struct value_size<itl::discrete_interval<DomainT> >
+struct value_size<icl::discrete_interval<DomainT> >
{
- static std::size_t apply(const itl::discrete_interval<DomainT>& value)
+ static std::size_t apply(const icl::discrete_interval<DomainT>& value)
{ return 2; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/dynamic_interval_traits.hpp
==============================================================================
--- sandbox/itl/boost/itl/dynamic_interval_traits.hpp (original)
+++ sandbox/itl/boost/itl/dynamic_interval_traits.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_DYNAMIC_INTERVAL_TRAITS_HPP_JOFA_100926
#define BOOST_ITL_DYNAMIC_INTERVAL_TRAITS_HPP_JOFA_100926
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
class interval_bounds;
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,20 +16,20 @@
#include <boost/itl/type_traits/is_set.hpp>
#include <boost/itl/type_traits/has_set_semantics.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ------------------------------------------------------------------------
template <typename Type> struct identity_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
// ------------------------------------------------------------------------
template <typename Type> struct unit_element_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type identity_element() { return boost::itl::unit_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::unit_element<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -113,7 +113,7 @@
void operator()(Type& object, const Type& operand)const
{ object &= ~operand; }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -141,7 +141,7 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -166,7 +166,7 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -181,7 +181,7 @@
void operator()(Type& object, const Type& operand)const
{ insert(object,operand); }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -196,7 +196,7 @@
void operator()(Type& object, const Type& operand)const
{ erase(object,operand); }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -211,7 +211,7 @@
void operator()(Type& object, const Type& operand)const
{ object *= operand; }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -226,7 +226,7 @@
void operator()(Type& object, const Type& operand)const
{ object /= operand; }
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -244,7 +244,7 @@
object = operand;
}
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -262,7 +262,7 @@
object = operand;
}
- static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
+ static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
};
template<>
@@ -276,8 +276,8 @@
{
typedef typename boost::mpl::
if_<has_set_semantics<Type>,
- itl::inplace_et<Type>,
- itl::inplace_plus<Type>
+ icl::inplace_et<Type>,
+ icl::inplace_plus<Type>
>::type
type;
@@ -293,65 +293,65 @@
template<class Functor> struct inverse;
template<class Type>
- struct inverse<itl::inplace_plus<Type> >
- { typedef itl::inplace_minus<Type> type; };
+ struct inverse<icl::inplace_plus<Type> >
+ { typedef icl::inplace_minus<Type> type; };
template<class Type>
- struct inverse<itl::inplace_minus<Type> >
- { typedef itl::inplace_plus<Type> type; };
+ struct inverse<icl::inplace_minus<Type> >
+ { typedef icl::inplace_plus<Type> type; };
template<class Type>
- struct inverse<itl::inplace_bit_add<Type> >
- { typedef itl::inplace_bit_subtract<Type> type; };
+ struct inverse<icl::inplace_bit_add<Type> >
+ { typedef icl::inplace_bit_subtract<Type> type; };
template<class Type>
- struct inverse<itl::inplace_bit_subtract<Type> >
- { typedef itl::inplace_bit_add<Type> type; };
+ struct inverse<icl::inplace_bit_subtract<Type> >
+ { typedef icl::inplace_bit_add<Type> type; };
template<class Type>
- struct inverse<itl::inplace_et<Type> >
- { typedef itl::inplace_caret<Type> type; };
+ struct inverse<icl::inplace_et<Type> >
+ { typedef icl::inplace_caret<Type> type; };
template<class Type>
- struct inverse<itl::inplace_caret<Type> >
- { typedef itl::inplace_et<Type> type; };
+ struct inverse<icl::inplace_caret<Type> >
+ { typedef icl::inplace_et<Type> type; };
template<class Type>
- struct inverse<itl::inplace_bit_and<Type> >
- { typedef itl::inplace_bit_xor<Type> type; };
+ struct inverse<icl::inplace_bit_and<Type> >
+ { typedef icl::inplace_bit_xor<Type> type; };
template<class Type>
- struct inverse<itl::inplace_bit_xor<Type> >
- { typedef itl::inplace_bit_and<Type> type; };
+ struct inverse<icl::inplace_bit_xor<Type> >
+ { typedef icl::inplace_bit_and<Type> type; };
template<class Type>
- struct inverse<itl::inplace_star<Type> >
- { typedef itl::inplace_slash<Type> type; };
+ struct inverse<icl::inplace_star<Type> >
+ { typedef icl::inplace_slash<Type> type; };
template<class Type>
- struct inverse<itl::inplace_slash<Type> >
- { typedef itl::inplace_star<Type> type; };
+ struct inverse<icl::inplace_slash<Type> >
+ { typedef icl::inplace_star<Type> type; };
template<class Type>
- struct inverse<itl::inplace_max<Type> >
- { typedef itl::inplace_min<Type> type; };
+ struct inverse<icl::inplace_max<Type> >
+ { typedef icl::inplace_min<Type> type; };
template<class Type>
- struct inverse<itl::inplace_min<Type> >
- { typedef itl::inplace_max<Type> type; };
+ struct inverse<icl::inplace_min<Type> >
+ { typedef icl::inplace_max<Type> type; };
//--------------------------------------------------------------------------
// Inverse inter_section functor
//--------------------------------------------------------------------------
template<class Type>
- struct inverse<itl::inter_section<Type> >
+ struct inverse<icl::inter_section<Type> >
: public identity_based_inplace_combine<Type>
{
typedef typename boost::mpl::
if_<has_set_semantics<Type>,
- itl::inplace_caret<Type>,
- itl::inplace_minus<Type>
+ icl::inplace_caret<Type>,
+ icl::inplace_minus<Type>
>::type
type;
@@ -387,14 +387,14 @@
};
template<class Type>
- struct is_negative<itl::inplace_minus<Type> >
+ struct is_negative<icl::inplace_minus<Type> >
{
typedef is_negative type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template<class Type>
- struct is_negative<itl::inplace_bit_subtract<Type> >
+ struct is_negative<icl::inplace_bit_subtract<Type> >
{
typedef is_negative type;
BOOST_STATIC_CONSTANT(bool, value = true);
@@ -445,19 +445,19 @@
{ return base_type::proversion(value); }
};
- template<>struct version<itl::inplace_minus<short > >{short operator()(short val){return -val;}};
- template<>struct version<itl::inplace_minus<int > >{int operator()(int val){return -val;}};
- template<>struct version<itl::inplace_minus<long > >{long operator()(long val){return -val;}};
- template<>struct version<itl::inplace_minus<long long > >{long long operator()(long long val){return -val;}};
- template<>struct version<itl::inplace_minus<float > >{float operator()(float val){return -val;}};
- template<>struct version<itl::inplace_minus<double > >{double operator()(double val){return -val;}};
- template<>struct version<itl::inplace_minus<long double> >{long double operator()(long double val){return -val;}};
+ template<>struct version<icl::inplace_minus<short > >{short operator()(short val){return -val;}};
+ template<>struct version<icl::inplace_minus<int > >{int operator()(int val){return -val;}};
+ template<>struct version<icl::inplace_minus<long > >{long operator()(long val){return -val;}};
+ template<>struct version<icl::inplace_minus<long long > >{long long operator()(long long val){return -val;}};
+ template<>struct version<icl::inplace_minus<float > >{float operator()(float val){return -val;}};
+ template<>struct version<icl::inplace_minus<double > >{double operator()(double val){return -val;}};
+ template<>struct version<icl::inplace_minus<long double> >{long double operator()(long double val){return -val;}};
template<class Type>
- struct version<itl::inplace_minus<Type> > : public conversion<itl::inplace_minus<Type> >
+ struct version<icl::inplace_minus<Type> > : public conversion<icl::inplace_minus<Type> >
{
- typedef version<itl::inplace_minus<Type> > type;
- typedef conversion<itl::inplace_minus<Type> > base_type;
+ typedef version<icl::inplace_minus<Type> > type;
+ typedef conversion<icl::inplace_minus<Type> > base_type;
typedef typename base_type::argument_type argument_type;
Type operator()(const Type& value)
@@ -466,7 +466,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/gregorian.hpp
==============================================================================
--- sandbox/itl/boost/itl/gregorian.hpp (original)
+++ sandbox/itl/boost/itl/gregorian.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -29,7 +29,7 @@
#include <boost/itl/type_traits/difference_type_of.hpp>
#include <boost/itl/type_traits/size_type_of.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<> struct is_discrete<boost::gregorian::date>
{
@@ -95,7 +95,7 @@
// ------------------------------------------------------------------------
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/interval_type_default.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
@@ -72,23 +72,23 @@
}
static inline interval_type construct(const DomainT& low, const DomainT& up)
- { return itl::construct<interval_type>(low, up); }
+ { return icl::construct<interval_type>(low, up); }
#else // ITL_USE_DYNAMIC_INTERVAL_BORDER_DEFAULTS
static inline interval_type right_open(const DomainT& low, const DomainT& up)
- { return itl::construct<interval_type>(low, up, interval_bounds::right_open()); }
+ { return icl::construct<interval_type>(low, up, interval_bounds::right_open()); }
static inline interval_type left_open(const DomainT& low, const DomainT& up)
- { return itl::construct<interval_type>(low, up, interval_bounds::left_open()); }
+ { return icl::construct<interval_type>(low, up, interval_bounds::left_open()); }
static inline interval_type open(const DomainT& low, const DomainT& up)
- { return itl::construct<interval_type>(low, up, interval_bounds::open()); }
+ { return icl::construct<interval_type>(low, up, interval_bounds::open()); }
static inline interval_type closed(const DomainT& low, const DomainT& up)
- { return itl::construct<interval_type>(low, up, interval_bounds::closed()); }
+ { return icl::construct<interval_type>(low, up, interval_bounds::closed()); }
static inline interval_type construct(const DomainT& low, const DomainT& up)
- { return itl::construct<interval_type>(low, up); }
+ { return icl::construct<interval_type>(low, up); }
#endif
};
@@ -103,7 +103,7 @@
static inline IntervalT construct(const domain_type& low, const domain_type& up)
{
- return itl::construct<IntervalT>(
+ return icl::construct<IntervalT>(
shift_lower(interval_bounds(PretendedBounds), interval_bounds(RepresentedBounds), low)
, shift_upper(interval_bounds(PretendedBounds), interval_bounds(RepresentedBounds), up )
);
@@ -126,7 +126,7 @@
// interval<T>::closed(x,y) then interval<T>::type must be static_closed
// Conversion between 'PretendedBounds' and 'RepresentedBounds' is only possible
// for discrete domain_types.
- return itl::construct<IntervalT>(low, up);
+ return icl::construct<IntervalT>(low, up);
}
};
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -31,7 +31,7 @@
#define const_FOR_IMPLMAP(iter) for(typename ImplMapT::const_iterator iter=_map.begin(); (iter)!=_map.end(); (iter)++)
#define FOR_IMPLMAP(iter) for(typename ImplMapT::iterator iter=_map.begin(); (iter)!=_map.end(); (iter)++)
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class DomainT, class CodomainT>
@@ -55,10 +55,10 @@
class SubType,
typename DomainT,
typename CodomainT,
- class Traits = itl::partial_absorber,
+ class Traits = icl::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::inter_section, CodomainT),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, CodomainT),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
@@ -85,7 +85,7 @@
//- Associated types: Related types
//--------------------------------------------------------------------------
/// The atomized type representing the corresponding container of elements
- typedef typename itl::map<DomainT,CodomainT,
+ typedef typename icl::map<DomainT,CodomainT,
Traits,Compare,Combine,Section,Alloc> atomized_type;
//--------------------------------------------------------------------------
@@ -180,13 +180,13 @@
typedef typename ImplMapT::const_reverse_iterator const_reverse_iterator;
/// element iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<iterator> element_iterator;
+ typedef boost::icl::element_iterator<iterator> element_iterator;
/// const element iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<const_iterator> element_const_iterator;
+ typedef boost::icl::element_iterator<const_iterator> element_const_iterator;
/// element reverse iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<reverse_iterator> element_reverse_iterator;
+ typedef boost::icl::element_iterator<reverse_iterator> element_reverse_iterator;
/// element const reverse iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
+ typedef boost::icl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
typedef typename on_absorbtion<type, codomain_combine,
Traits::absorbs_identities>::type on_codomain_absorbtion;
@@ -234,10 +234,10 @@
//= Containedness
//==========================================================================
/** clear the map */
- void clear() { itl::clear(*that()); }
+ void clear() { icl::clear(*that()); }
/** is the map empty? */
- bool empty()const { return itl::is_empty(*that()); }
+ bool empty()const { return icl::is_empty(*that()); }
//==========================================================================
//= Size
@@ -245,7 +245,7 @@
/** An interval map's size is it's cardinality */
size_type size()const
{
- return itl::cardinality(*that());
+ return icl::cardinality(*that());
}
/** Size of the iteration over this container */
@@ -284,7 +284,7 @@
/** Addition of a key value pair to the map */
SubType& add(const element_type& key_value_pair)
{
- return itl::add(*that(), key_value_pair);
+ return icl::add(*that(), key_value_pair);
}
/** Addition of an interval value pair to the map. */
@@ -308,7 +308,7 @@
/** Subtraction of a key value pair from the map */
SubType& subtract(const element_type& key_value_pair)
{
- return itl::subtract(*that(), key_value_pair);
+ return icl::subtract(*that(), key_value_pair);
}
/** Subtraction of an interval value pair from the map. */
@@ -325,7 +325,7 @@
/** Insertion of a \c key_value_pair into the map. */
SubType& insert(const element_type& key_value_pair)
{
- return itl::insert(*that(), key_value_pair);
+ return icl::insert(*that(), key_value_pair);
}
/** Insertion of an \c interval_value_pair into the map. */
@@ -345,14 +345,14 @@
/** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
SubType& set(const element_type& key_value_pair)
{
- return itl::set_at(*that(), key_value_pair);
+ return icl::set_at(*that(), key_value_pair);
}
/** With <tt>interval_value_pair = (I,v)</tt> set value \c v
for all keys in interval \c I in the map. */
SubType& set(const segment_type& interval_value_pair)
{
- return itl::set_at(*that(), interval_value_pair);
+ return icl::set_at(*that(), interval_value_pair);
}
//==========================================================================
@@ -361,7 +361,7 @@
/** Erase a \c key_value_pair from the map. */
SubType& erase(const element_type& key_value_pair)
{
- itl::erase(*that(), key_value_pair);
+ icl::erase(*that(), key_value_pair);
return *that();
}
@@ -371,7 +371,7 @@
/** Erase a key value pair for \c key. */
SubType& erase(const domain_type& key)
{
- return itl::erase(*that(), key);
+ return icl::erase(*that(), key);
}
/** Erase all value pairs within the range of the
@@ -402,7 +402,7 @@
/** 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 itl::flip(*that(), key_value_pair);
+ return icl::flip(*that(), key_value_pair);
}
/** If \c *this map contains \c interval_value_pair it is erased, otherwise it is added. */
@@ -493,7 +493,7 @@
void partial_add_intersection(SubType& section, const segment_type& operand)const
{
interval_type inter_val = operand.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return;
std::pair<const_iterator, const_iterator> exterior
@@ -504,7 +504,7 @@
for(const_iterator it_=exterior.first; it_ != exterior.second; it_++)
{
interval_type common_interval = it_->first & inter_val;
- if(!itl::is_empty(common_interval))
+ if(!icl::is_empty(common_interval))
{
section.template _add<codomain_combine> (value_type(common_interval, it_->second) );
section.template _add<codomain_intersect>(value_type(common_interval, operand.second));
@@ -680,7 +680,7 @@
struct on_total_absorbable<Type, true, true>
{
static void flip(Type& object, const typename Type::segment_type& operand)
- { itl::clear(object); }
+ { icl::clear(object); }
};
template<class Type>
@@ -696,7 +696,7 @@
it_->second = identity_element<codomain_type>::value();
if(mpl::not_<is_interval_splitter<Type> >::value)
- itl::join(object);
+ icl::join(object);
}
};
@@ -741,16 +741,16 @@
//That which is common ...
common_interval = span & covered;
- if(!itl::is_empty(common_interval))
+ if(!icl::is_empty(common_interval))
{
// ... shall be subtracted
- itl::add(eraser, common_interval);
+ icl::add(eraser, common_interval);
on_codomain_model<Type, has_set_semantics<codomain_type>::value>
::add(intersection, common_interval, x_value, co_value);
}
- itl::add(object, value_type(left_over, x_value)); //That which is not shall be added
+ icl::add(object, 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
@@ -760,10 +760,10 @@
}
//If span is not empty here, it is not in the set so it shall be added
- itl::add(object, value_type(span, x_value));
+ icl::add(object, value_type(span, x_value));
//finally rewrite the common segments
- itl::erase(object, eraser);
+ icl::erase(object, eraser);
object += intersection;
}
};
@@ -785,7 +785,7 @@
// only for the first there can be a left_resid: a part of *first_ left of inter_val
interval_type left_resid = right_subtract(first_->first, inter_val);
- if(!itl::is_empty(left_resid))
+ if(!icl::is_empty(left_resid))
{ // [------------ . . .
// [left_resid---first_ --- . . .
iterator prior_ = cyclic_prior(*this, first_);
@@ -805,7 +805,7 @@
::add_segment(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
{
interval_type lead_gap = right_subtract(inter_val, it_->first);
- if(!itl::is_empty(lead_gap))
+ if(!icl::is_empty(lead_gap))
{
// [lead_gap--- . . .
// [-- it_ ...
@@ -846,7 +846,7 @@
interval_type cur_itv = it_->first ;
interval_type lead_gap = right_subtract(inter_val, cur_itv);
- if(!itl::is_empty(lead_gap))
+ if(!icl::is_empty(lead_gap))
{ // [lead_gap--- . . .
// [prior) [-- it_ ...
iterator inserted_ = this->template gap_insert<Combiner>(prior_, lead_gap, co_val);
@@ -854,7 +854,7 @@
}
interval_type end_gap = left_subtract(inter_val, cur_itv);
- if(!itl::is_empty(end_gap))
+ if(!icl::is_empty(end_gap))
{
// [----------------end_gap)
// . . . -- it_ --)
@@ -866,7 +866,7 @@
// only for the last there can be a right_resid: a part of *it_ right of x
interval_type right_resid = left_subtract(cur_itv, inter_val);
- if(itl::is_empty(right_resid))
+ if(icl::is_empty(right_resid))
{
// [---------------)
// [-- it_ ---)
@@ -905,7 +905,7 @@
absorbs_identities<type>::value>::type on_absorbtion_;
const interval_type& inter_val = addend.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return this->_map.end();
const codomain_type& co_val = addend.second;
@@ -943,7 +943,7 @@
absorbs_identities<type>::value>::type on_absorbtion_;
const interval_type& inter_val = addend.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return prior_;
const codomain_type& co_val = addend.second;
@@ -980,7 +980,7 @@
{
interval_type left_resid = right_subtract(it_->first, inter_val);
- if(!itl::is_empty(left_resid)) // [--- inter_val ---)
+ if(!icl::is_empty(left_resid)) // [--- inter_val ---)
{ //[prior_) [left_resid)[--- it_ . . .
iterator prior_ = cyclic_prior(*this, it_);
const_cast<interval_type&>(it_->first) = left_subtract(it_->first, left_resid);
@@ -1010,7 +1010,7 @@
{
interval_type right_resid = left_subtract(it_->first, inter_val);
- if(itl::is_empty(right_resid))
+ if(icl::is_empty(right_resid))
{
Combiner()(it_->second, co_val);
that()->template handle_combined<Combiner>(it_);
@@ -1033,7 +1033,7 @@
::_subtract(const segment_type& minuend)
{
interval_type inter_val = minuend.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return;
const codomain_type& co_val = minuend.second;
@@ -1071,7 +1071,7 @@
cur_itv = it_->first ;
left_gap = right_subtract(rest_interval, cur_itv);
- if(!itl::is_empty(left_gap))
+ if(!icl::is_empty(left_gap))
{
inserted_ = this->_map.insert(prior_, value_type(left_gap, co_val));
it_ = that()->handle_inserted(inserted_);
@@ -1085,7 +1085,7 @@
//insert_rear(rest_interval, co_val, last_):
interval_type end_gap = left_subtract(rest_interval, last_interval);
- if(!itl::is_empty(end_gap))
+ if(!icl::is_empty(end_gap))
{
inserted_ = this->_map.insert(prior_, value_type(end_gap, co_val));
it_ = that()->handle_inserted(inserted_);
@@ -1101,7 +1101,7 @@
::_insert(const segment_type& addend)
{
interval_type inter_val = addend.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return this->_map.end();
const codomain_type& co_val = addend.second;
@@ -1131,7 +1131,7 @@
::_insert(iterator prior_, const segment_type& addend)
{
interval_type inter_val = addend.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return prior_;
const codomain_type& co_val = addend.second;
@@ -1170,7 +1170,7 @@
if(it_->second == co_val)
{
interval_type right_resid = left_subtract(it_->first, inter_val);
- if(itl::is_empty(right_resid))
+ if(icl::is_empty(right_resid))
this->_map.erase(it_);
else
const_cast<interval_type&>(it_->first) = right_resid;
@@ -1182,7 +1182,7 @@
::erase(const segment_type& minuend)
{
interval_type inter_val = minuend.first;
- if(itl::is_empty(inter_val))
+ if(icl::is_empty(inter_val))
return *that();
const codomain_type& co_val = minuend.second;
@@ -1206,13 +1206,13 @@
if(first_->second == co_val)
{
interval_type left_resid = right_subtract(first_->first, inter_val);
- if(!itl::is_empty(left_resid)) // [----inter_val----)
+ if(!icl::is_empty(left_resid)) // [----inter_val----)
{ // [left_resid)..first_==last_......
const_cast<interval_type&>(first_->first) = left_resid;
- if(!itl::is_empty(right_resid))
+ if(!icl::is_empty(right_resid))
this->_map.insert(first_, value_type(right_resid, co_val));
}
- else if(!itl::is_empty(right_resid))
+ else if(!icl::is_empty(right_resid))
const_cast<interval_type&>(first_->first) = right_resid;
else
this->_map.erase(first_);
@@ -1224,7 +1224,7 @@
if(first_->second == co_val)
{
interval_type left_resid = right_subtract(first_->first, inter_val);
- if(itl::is_empty(left_resid))
+ if(icl::is_empty(left_resid))
this->_map.erase(first_);
else
const_cast<interval_type&>(first_->first) = left_resid;
@@ -1243,7 +1243,7 @@
inline SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::erase(const interval_type& minuend)
{
- if(itl::is_empty(minuend))
+ if(icl::is_empty(minuend))
return *that();
std::pair<iterator, iterator> exterior = this->_map.equal_range(minuend);
@@ -1258,13 +1258,13 @@
interval_type right_resid = left_subtract(last_ ->first, minuend);
if(first_ == last_ )
- if(!itl::is_empty(left_resid))
+ if(!icl::is_empty(left_resid))
{
const_cast<interval_type&>(first_->first) = left_resid;
- if(!itl::is_empty(right_resid))
+ if(!icl::is_empty(right_resid))
this->_map.insert(first_, value_type(right_resid, first_->second));
}
- else if(!itl::is_empty(right_resid))
+ else if(!icl::is_empty(right_resid))
const_cast<interval_type&>(first_->first) = left_subtract(first_->first, minuend);
else
this->_map.erase(first_);
@@ -1273,14 +1273,14 @@
// [left_resid fst) . . . . [lst right_resid)
iterator second_= first_; ++second_;
- iterator start_ = itl::is_empty(left_resid)? first_: second_;
- iterator stop_ = itl::is_empty(right_resid)? end_ : last_ ;
+ iterator start_ = icl::is_empty(left_resid)? first_: second_;
+ iterator stop_ = icl::is_empty(right_resid)? end_ : last_ ;
this->_map.erase(start_, stop_); //erase [start_, stop_)
- if(!itl::is_empty(left_resid))
+ if(!icl::is_empty(left_resid))
const_cast<interval_type&>(first_->first) = left_resid;
- if(!itl::is_empty(right_resid))
+ if(!icl::is_empty(right_resid))
const_cast<interval_type&>(last_ ->first) = right_resid;
}
@@ -1295,9 +1295,9 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
-struct is_map<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_map<icl::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;
+ typedef is_map<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -1306,9 +1306,9 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
-struct has_inverse<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct has_inverse<icl::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;
+ typedef has_inverse<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
@@ -1317,9 +1317,9 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
-struct is_interval_container<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_interval_container<icl::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;
+ typedef is_interval_container<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -1328,9 +1328,9 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
-struct absorbs_identities<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct absorbs_identities<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_identities<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ typedef absorbs_identities<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
};
@@ -1339,15 +1339,15 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
-struct is_total<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_total<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef is_total<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ typedef is_total<icl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total));
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -35,7 +35,7 @@
#define FOR_IMPL(iter) for(typename ImplSetT::iterator iter=_set.begin(); (iter)!=_set.end(); (iter)++)
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief Implements a set as a set of intervals (base class) */
@@ -65,7 +65,7 @@
//- Associated types: Related types
//--------------------------------------------------------------------------
/// The atomized type representing the corresponding container of elements
- typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
+ typedef typename icl::set<DomainT,Compare,Alloc> atomized_type;
//--------------------------------------------------------------------------
//- Associated types: Data
@@ -143,13 +143,13 @@
typedef typename ImplSetT::const_reverse_iterator const_reverse_iterator;
/// element iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<iterator> element_iterator;
+ typedef boost::icl::element_iterator<iterator> element_iterator;
/// element const iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<const_iterator> element_const_iterator;
+ typedef boost::icl::element_iterator<const_iterator> element_const_iterator;
/// element reverse iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<reverse_iterator> element_reverse_iterator;
+ typedef boost::icl::element_iterator<reverse_iterator> element_reverse_iterator;
/// element const reverse iterator: Depreciated, see documentation.
- typedef boost::itl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
+ typedef boost::icl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
BOOST_STATIC_CONSTANT(int, fineness = 0);
@@ -177,9 +177,9 @@
//= Containedness
//==========================================================================
/** sets the container empty */
- void clear() { itl::clear(*that()); }
+ void clear() { icl::clear(*that()); }
/** is the container empty? */
- bool empty()const { return itl::is_empty(*that()); }
+ bool empty()const { return icl::is_empty(*that()); }
//==========================================================================
//= Size
@@ -187,7 +187,7 @@
/** An interval set's size is it's cardinality */
size_type size()const
{
- return itl::cardinality(*that());
+ return icl::cardinality(*that());
}
/** Size of the iteration over this container */
@@ -203,7 +203,7 @@
/** Find the interval value pair, that contains element \c key */
const_iterator find(const element_type& key)const
{
- return this->_set.find(itl::singleton<segment_type>(key));
+ return this->_set.find(icl::singleton<segment_type>(key));
}
const_iterator find(const segment_type& segment)const
@@ -218,7 +218,7 @@
/** Add a single element \c key to the set */
SubType& add(const element_type& key)
{
- return itl::add(*that(), key);
+ return icl::add(*that(), key);
}
/** Add an interval of elements \c inter_val to the set */
@@ -243,7 +243,7 @@
/** Subtract a single element \c key from the set */
SubType& subtract(const element_type& key)
{
- return itl::subtract(*that(), key);
+ return icl::subtract(*that(), key);
}
/** Subtract an interval of elements \c inter_val from the set */
@@ -307,13 +307,13 @@
/** If \c *this set contains \c key it is erased, otherwise it is added. */
SubType& flip(const element_type& key)
{
- return itl::flip(*that(), key);
+ return icl::flip(*that(), key);
}
/** If \c *this set contains \c inter_val it is erased, otherwise it is added. */
SubType& flip(const segment_type& inter_val)
{
- return itl::flip(*that(), inter_val);
+ return icl::flip(*that(), inter_val);
}
//==========================================================================
@@ -377,7 +377,7 @@
// only for the first there can be a left_resid: a part of *first_ left of inter_val
interval_type left_resid = right_subtract(*first_, inter_val);
- if(!itl::is_empty(left_resid))
+ if(!icl::is_empty(left_resid))
{ // [------------ . . .
// [left_resid---first_ --- . . .
iterator prior_ = cyclic_prior(*this, first_);
@@ -396,7 +396,7 @@
::add_segment(const interval_type& inter_val, iterator& it_)
{
interval_type lead_gap = right_subtract(inter_val, *it_);
- if(!itl::is_empty(lead_gap))
+ if(!icl::is_empty(lead_gap))
// [lead_gap--- . . .
// [prior_) [-- it_ ...
this->_set.insert(prior(it_), lead_gap);
@@ -428,13 +428,13 @@
interval_type cur_itv = *it_;
interval_type lead_gap = right_subtract(inter_val, cur_itv);
- if(!itl::is_empty(lead_gap))
+ if(!icl::is_empty(lead_gap))
// [lead_gap--- . . .
// [prior_) [-- it_ ...
this->_set.insert(prior_, lead_gap);
interval_type end_gap = left_subtract(inter_val, cur_itv);
- if(!itl::is_empty(end_gap))
+ if(!icl::is_empty(end_gap))
// [---------------end_gap)
// [-- it_ --)
it_ = this->_set.insert(it_, end_gap);
@@ -443,7 +443,7 @@
// only for the last there can be a right_resid: a part of *it_ right of addend
interval_type right_resid = left_subtract(cur_itv, inter_val);
- if(!itl::is_empty(right_resid))
+ if(!icl::is_empty(right_resid))
{
// [--------------)
// [-- it_ --right_resid)
@@ -461,7 +461,7 @@
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::_add(const segment_type& addend)
{
- if(itl::is_empty(addend))
+ if(icl::is_empty(addend))
return this->_set.end();
std::pair<iterator,bool> insertion = this->_set.insert(addend);
@@ -477,7 +477,7 @@
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::_add(iterator prior_, const segment_type& addend)
{
- if(itl::is_empty(addend))
+ if(icl::is_empty(addend))
return prior_;
iterator insertion = this->_set.insert(prior_, addend);
@@ -495,7 +495,7 @@
inline SubType& interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
::subtract(const segment_type& minuend)
{
- if(itl::is_empty(minuend))
+ if(icl::is_empty(minuend))
return *that();
std::pair<iterator, iterator> exterior = this->_set.equal_range(minuend);
@@ -513,10 +513,10 @@
this->_set.erase(first_, end_);
- if(!itl::is_empty(left_resid))
+ if(!icl::is_empty(left_resid))
this->_set.insert(left_resid);
- if(!itl::is_empty(right_resid))
+ if(!icl::is_empty(right_resid))
this->_set.insert(right_resid);
return *that();
@@ -527,23 +527,23 @@
//-----------------------------------------------------------------------------
template<class SubType,
class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
+struct is_set<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
+ typedef is_set<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template<class SubType,
class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
+struct is_interval_container<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_container<icl::interval_base_set<SubType,DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/interval_bounds.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_bounds.hpp (original)
+++ sandbox/itl/boost/itl/interval_bounds.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/utility/enable_if.hpp>
#include <boost/itl/detail/design_config.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
typedef unsigned char bound_type;
@@ -74,7 +74,7 @@
interval_bounds _bound;
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/interval_combining_style.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_combining_style.hpp (original)
+++ sandbox/itl/boost/itl/interval_combining_style.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_INTERVAL_COMBINING_STYLE_HPP_JOFA_100906
#define BOOST_ITL_INTERVAL_COMBINING_STYLE_HPP_JOFA_100906
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace interval_combine
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/interval_set.hpp>
#include <boost/itl/interval_base_map.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class DomainT, class CodomainT, class Traits,
@@ -27,10 +27,10 @@
<
typename DomainT,
typename CodomainT,
- class Traits = itl::partial_absorber,
+ class Traits = icl::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::inter_section, CodomainT),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, CodomainT),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
@@ -207,38 +207,38 @@
// type traits
//-----------------------------------------------------------------------------
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_map<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_map<icl::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;
+ typedef is_map<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct has_inverse<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct has_inverse<icl::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;
+ typedef has_inverse<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_container<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_interval_container<icl::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;
+ typedef is_interval_container<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct absorbs_identities<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct absorbs_identities<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_identities<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ typedef absorbs_identities<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_total<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_total<icl::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;
+ typedef is_total<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total));
};
@@ -247,7 +247,7 @@
// type representation
//-----------------------------------------------------------------------------
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct type_to_string<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct type_to_string<icl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
static std::string apply()
{
@@ -257,7 +257,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/type_traits/is_interval_joiner.hpp>
#include <boost/itl/interval_base_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief Implements a set as a set of intervals - merging adjoining intervals */
@@ -68,10 +68,10 @@
typedef Alloc<DomainT> domain_allocator_type;
/// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
+ typedef typename icl::set<DomainT,Compare,Alloc> atomized_type;
/// Container type for the implementation
- typedef typename itl::set<interval_type,ITL_EXCLUSIVE_LESS(interval_type),Alloc> ImplSetT;
+ typedef typename icl::set<interval_type,ITL_EXCLUSIVE_LESS(interval_type),Alloc> ImplSetT;
/// key type of the implementing container
typedef typename ImplSetT::key_type key_type;
@@ -166,23 +166,23 @@
// type traits
//-----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_set<icl::interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_set<icl::interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_interval_container<icl::interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_container<icl::interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_joiner<itl::interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_interval_joiner<icl::interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_joiner<itl::interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_joiner<icl::interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -191,13 +191,13 @@
// type representation
//-----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct type_to_string<itl::interval_set<DomainT,Compare,Interval,Alloc> >
+struct type_to_string<icl::interval_set<DomainT,Compare,Interval,Alloc> >
{
static std::string apply()
{ return "itv_set<"+ type_to_string<DomainT>::apply() +">"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/interval_traits.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_traits.hpp (original)
+++ sandbox/itl/boost/itl/interval_traits.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/difference_type_of.hpp>
#include <boost/itl/type_traits/size_type_of.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type> struct interval_traits;
Modified: sandbox/itl/boost/itl/iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl/iterator.hpp (original)
+++ sandbox/itl/boost/itl/iterator.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <iterator>
#include <boost/config/warning_disable.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief Performes an addition using a container's memberfunction add, when operator= is called. */
@@ -96,7 +96,7 @@
return insert_iterator<ContainerT>(cont, typename ContainerT::iterator(iter_));
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_ITERATOR_HPP_JOFA_091003
Modified: sandbox/itl/boost/itl/left_open_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/left_open_interval.hpp (original)
+++ sandbox/itl/boost/itl/left_open_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class DomainT,
@@ -47,7 +47,7 @@
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
// Only for discrete types this ctor creates an interval containing
// a single element only.
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
BOOST_ASSERT((numeric_minimum<DomainT, is_numeric<DomainT>::value >::is_less_than(val) ));
}
@@ -71,11 +71,11 @@
//=T left_open_interval -> concept intervals
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::left_open_interval<DomainT, Compare> >
+struct interval_traits< icl::left_open_interval<DomainT, Compare> >
{
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::left_open_interval<DomainT, Compare> interval_type;
+ typedef icl::left_open_interval<DomainT, Compare> interval_type;
static interval_type construct(const domain_type& lo, const domain_type& up)
{
@@ -98,20 +98,20 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::left_open_interval<DomainT,Compare> >
+struct type_to_string<icl::left_open_interval<DomainT,Compare> >
{
static std::string apply()
{ return "(I]<"+ type_to_string<DomainT>::apply() +">"; }
};
template<class DomainT, ITL_COMPARE Compare>
-struct value_size<itl::left_open_interval<DomainT,Compare> >
+struct value_size<icl::left_open_interval<DomainT,Compare> >
{
- static std::size_t apply(const itl::left_open_interval<DomainT>& value)
+ static std::size_t apply(const icl::left_open_interval<DomainT>& value)
{ return 2; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -40,7 +40,7 @@
#include <boost/itl/concept/element_map.hpp>
#include <boost/itl/concept/element_associator.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
struct partial_absorber
@@ -86,10 +86,10 @@
<
typename DomainT,
typename CodomainT,
- class Traits = itl::partial_absorber,
+ class Traits = icl::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::inter_section, CodomainT),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, CodomainT),
ITL_ALLOC Alloc = std::allocator
>
class map: private ITL_IMPL_SPACE::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
@@ -98,10 +98,10 @@
public:
typedef Alloc<typename std::pair<const DomainT, CodomainT> > allocator_type;
- typedef typename itl::map<DomainT,CodomainT,Traits, Compare,Combine,Section,Alloc> type;
+ typedef typename icl::map<DomainT,CodomainT,Traits, Compare,Combine,Section,Alloc> type;
typedef typename ITL_IMPL_SPACE::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
allocator_type> base_type;
- typedef typename itl::set<DomainT, Compare, Alloc > set_type;
+ typedef typename icl::set<DomainT, Compare, Alloc > set_type;
typedef set_type key_object_type;
typedef Traits traits;
@@ -227,10 +227,10 @@
template<class SubObject>
bool contains(const SubObject& sub)const
- { return itl::contains(*this, sub); }
+ { return icl::contains(*this, sub); }
bool within(const map& super)const
- { return itl::contains(super, *this); }
+ { return icl::contains(super, *this); }
//==========================================================================
//= Size
@@ -285,7 +285,7 @@
map& subtract(const domain_type& key)
{
- itl::erase(*this, key);
+ icl::erase(*this, key);
return *this;
}
@@ -311,14 +311,14 @@
/** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
map& set(const element_type& key_value_pair)
{
- return itl::set_at(*this, key_value_pair);
+ return icl::set_at(*this, key_value_pair);
}
/** erase \c key_value_pair from the map.
Erase only if, the exact value content \c val is stored for the given key. */
size_type erase(const element_type& key_value_pair)
{
- return itl::erase(*this, key_value_pair);
+ return icl::erase(*this, key_value_pair);
}
//==========================================================================
@@ -476,7 +476,7 @@
{
typedef typename Type::element_type element_type;
static void flip(Type& object, const typename Type::element_type&)
- { itl::clear(object); }
+ { icl::clear(object); }
};
template<class Type>
@@ -621,35 +621,35 @@
// type traits
//-----------------------------------------------------------------------------
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> >
+struct is_map<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef is_map<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
+ typedef is_map<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
BOOST_STATIC_CONSTANT(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> >
+struct has_inverse<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef has_inverse<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
+ typedef has_inverse<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
BOOST_STATIC_CONSTANT(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 absorbs_identities<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
+struct absorbs_identities<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef absorbs_identities type;
BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-struct is_total<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
+struct is_total<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef is_total type;
BOOST_STATIC_CONSTANT(int, value = Traits::is_total);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-struct type_to_string<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
+struct type_to_string<icl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
static std::string apply()
{
@@ -661,7 +661,7 @@
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_MAP_HPP_JOFA_070519
Modified: sandbox/itl/boost/itl/open_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/open_interval.hpp (original)
+++ sandbox/itl/boost/itl/open_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class DomainT,
@@ -47,7 +47,7 @@
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
// Only for discrete types this ctor creates an interval containing
// a single element only.
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
BOOST_ASSERT((numeric_minimum<DomainT, is_numeric<DomainT>::value >::is_less_than(val) ));
}
@@ -71,11 +71,11 @@
//=T open_interval -> concept intervals
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::open_interval<DomainT, Compare> >
+struct interval_traits< icl::open_interval<DomainT, Compare> >
{
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::open_interval<DomainT, Compare> interval_type;
+ typedef icl::open_interval<DomainT, Compare> interval_type;
static interval_type construct(const domain_type& lo, const domain_type& up)
{
@@ -98,20 +98,20 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::open_interval<DomainT,Compare> >
+struct type_to_string<icl::open_interval<DomainT,Compare> >
{
static std::string apply()
{ return "(I)<"+ type_to_string<DomainT>::apply() +">"; }
};
template<class DomainT, ITL_COMPARE Compare>
-struct value_size<itl::open_interval<DomainT,Compare> >
+struct value_size<icl::open_interval<DomainT,Compare> >
{
- static std::size_t apply(const itl::open_interval<DomainT>& value)
+ static std::size_t apply(const icl::open_interval<DomainT>& value)
{ return 2; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/predicates.hpp
==============================================================================
--- sandbox/itl/boost/itl/predicates.hpp (original)
+++ sandbox/itl/boost/itl/predicates.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <functional>
#include <boost/itl/type_traits/type_to_string.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// naming convention
// predicate: n-ary predicate
@@ -66,7 +66,7 @@
//-----------------------------------------------------------------------------
template<>
- inline std::string unary_template_to_string<itl::std_equal>::apply()
+ inline std::string unary_template_to_string<icl::std_equal>::apply()
{ return "=="; }
template <class Type>
@@ -79,7 +79,7 @@
};
template<>
- inline std::string unary_template_to_string<itl::element_equal>::apply()
+ inline std::string unary_template_to_string<icl::element_equal>::apply()
{ return "="; }
template <class Type>
@@ -92,7 +92,7 @@
};
template<>
- inline std::string unary_template_to_string<itl::distinct_equal>::apply()
+ inline std::string unary_template_to_string<icl::distinct_equal>::apply()
{ return "==/0"; }
@@ -111,7 +111,7 @@
};
template<>
- inline std::string unary_template_to_string<itl::sub_super_set>::apply()
+ inline std::string unary_template_to_string<icl::sub_super_set>::apply()
{ return "C="; }
/// Functor class template <b>contains</b> implements the superset relation.
@@ -128,10 +128,10 @@
};
template<>
- inline std::string unary_template_to_string<itl::super_sub_set>::apply()
+ inline std::string unary_template_to_string<icl::super_sub_set>::apply()
{ return "D="; }
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/ptime.hpp
==============================================================================
--- sandbox/itl/boost/itl/ptime.hpp (original)
+++ sandbox/itl/boost/itl/ptime.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -37,7 +37,7 @@
#include <boost/itl/type_traits/size_type_of.hpp>
#include <boost/itl/type_traits/is_discrete.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<> struct is_discrete<boost::posix_time::ptime>
{
@@ -91,7 +91,7 @@
{
return x -= boost::posix_time::ptime::time_duration_type::unit();
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/rational.hpp
==============================================================================
--- sandbox/itl/boost/itl/rational.hpp (original)
+++ sandbox/itl/boost/itl/rational.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -30,7 +30,7 @@
#include <boost/itl/type_traits/has_inverse.hpp>
#include <boost/itl/type_traits/is_numeric.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class Integral>
struct is_numeric<boost::rational<Integral> >
@@ -60,7 +60,7 @@
BOOST_STATIC_CONSTANT(bool, value = (is_signed<Integral>::value));
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/right_open_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/right_open_interval.hpp (original)
+++ sandbox/itl/boost/itl/right_open_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class DomainT,
@@ -47,7 +47,7 @@
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
// Only for discrete types this ctor creates an interval containing
// a single element only.
- BOOST_STATIC_ASSERT((itl::is_discrete<DomainT>::value));
+ BOOST_STATIC_ASSERT((icl::is_discrete<DomainT>::value));
}
/** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bounds</tt> */
@@ -70,11 +70,11 @@
//=T right_open_interval -> concept intervals
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
-struct interval_traits< itl::right_open_interval<DomainT, Compare> >
+struct interval_traits< icl::right_open_interval<DomainT, Compare> >
{
typedef DomainT domain_type;
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef itl::right_open_interval<DomainT, Compare> interval_type;
+ typedef icl::right_open_interval<DomainT, Compare> interval_type;
static interval_type construct(const domain_type& lo, const domain_type& up)
{
@@ -97,20 +97,20 @@
};
template <class DomainT, ITL_COMPARE Compare>
-struct type_to_string<itl::right_open_interval<DomainT,Compare> >
+struct type_to_string<icl::right_open_interval<DomainT,Compare> >
{
static std::string apply()
{ return "[I)<"+ type_to_string<DomainT>::apply() +">"; }
};
template<class DomainT, ITL_COMPARE Compare>
-struct value_size<itl::right_open_interval<DomainT,Compare> >
+struct value_size<icl::right_open_interval<DomainT,Compare> >
{
- static std::size_t apply(const itl::right_open_interval<DomainT>& value)
+ static std::size_t apply(const icl::right_open_interval<DomainT>& value)
{ return 2; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/interval_base_set.hpp>
#include <boost/itl/interval_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief Implements a set as a set of intervals - leaving adjoining intervals separate */
@@ -65,10 +65,10 @@
typedef Alloc<DomainT> domain_allocator_type;
/// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
+ typedef typename icl::set<DomainT,Compare,Alloc> atomized_type;
/// Container type for the implementation
- typedef typename itl::set<interval_type,ITL_EXCLUSIVE_LESS(interval_type),Alloc> ImplSetT;
+ typedef typename icl::set<interval_type,ITL_EXCLUSIVE_LESS(interval_type),Alloc> ImplSetT;
/// key type of the implementing container
typedef typename ImplSetT::key_type key_type;
@@ -154,23 +154,23 @@
// type traits
//-----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_set<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_set<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_interval_container<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_container<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_interval_separator<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_separator<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_separator<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -178,13 +178,13 @@
// type representation
//-----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct type_to_string<itl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
+struct type_to_string<icl::separate_interval_set<DomainT,Compare,Interval,Alloc> >
{
static std::string apply()
{ return "se_itv_set<"+ type_to_string<DomainT>::apply() +">"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -36,7 +36,7 @@
#include <boost/itl/concept/comparable.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief Addable, subtractable and intersectable sets. */
@@ -49,7 +49,7 @@
class set: private ITL_IMPL_SPACE::set<DomainT, ITL_COMPARE_DOMAIN(Compare,DomainT), Alloc<DomainT> >
{
public:
- typedef typename itl::set<DomainT, Compare, Alloc> type;
+ typedef typename icl::set<DomainT, Compare, Alloc> type;
typedef typename ITL_IMPL_SPACE::set<DomainT, ITL_COMPARE_DOMAIN(Compare,DomainT), Alloc<DomainT> > base_type;
typedef type key_object_type;
@@ -150,19 +150,19 @@
/// Checks if the element \c value is in the set
bool contains(const element_type& value)const
- { return itl::contains(*this, value); }
+ { return icl::contains(*this, value); }
/** Does <tt>*this</tt> contain <tt>sub</tt>? */
bool contains(const set& sub)const
- { return itl::contains(*this, sub); }
+ { return icl::contains(*this, sub); }
/** Is <tt>*this</tt> contained in <tt>super</tt>? */
bool contained_in(const set& super)const
- { return itl::within(*this, super); }
+ { return icl::within(*this, super); }
/** <tt>*this</tt> and <tt>x2</tt> are disjoint, if their intersection is empty */
bool disjoint(const set& x2)const
- { return itl::disjoint(*this, x2); }
+ { return icl::disjoint(*this, x2); }
//==========================================================================
//= Size
@@ -179,22 +179,22 @@
//==========================================================================
/** Add an \c element to the set. */
set& add(const element_type& element)
- { return itl::insert(*this, element); }
+ { return icl::insert(*this, element); }
/** Add an element \c element after \c prior to the set. */
iterator add(iterator prior, const element_type& element)
- { return itl::insert(*this, prior, element); }
+ { return icl::insert(*this, prior, element); }
/** Subtract an \c element from the set. */
set& subtract(const element_type& element)
- { return itl::subtract(*this, element); }
+ { return icl::subtract(*this, element); }
//==========================================================================
//= Symmetric difference
//==========================================================================
/** If \c *this set contains \c element it is erased, otherwise it is added. */
set& flip(const element_type& element)
- { return itl::flip(*this, element); }
+ { return icl::flip(*this, element); }
};
@@ -203,21 +203,21 @@
// type traits
//-----------------------------------------------------------------------------
template <class Type>
-struct is_set<itl::set<Type> >
+struct is_set<icl::set<Type> >
{
- typedef is_set<itl::set<Type> > type;
+ typedef is_set<icl::set<Type> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class Type>
-struct type_to_string<itl::set<Type> >
+struct type_to_string<icl::set<Type> >
{
static std::string apply()
{ return "set<"+ type_to_string<Type>::apply() +">"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_SET_HPP_JOFA_070519
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/interval_base_map.hpp>
#include <boost/itl/split_interval_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief implements a map as a map of intervals - on insertion
@@ -23,10 +23,10 @@
<
typename DomainT,
typename CodomainT,
- class Traits = itl::partial_absorber,
+ class Traits = icl::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::inter_section, CodomainT),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, CodomainT),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare),
ITL_ALLOC Alloc = std::allocator
>
@@ -153,50 +153,50 @@
// type traits
//-----------------------------------------------------------------------------
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_map<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_map<icl::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;
+ typedef is_map<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct has_inverse<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct has_inverse<icl::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;
+ typedef has_inverse<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (has_inverse<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_container<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_interval_container<icl::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;
+ typedef is_interval_container<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_splitter<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_interval_splitter<icl::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;
+ typedef is_interval_splitter<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct absorbs_identities<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct absorbs_identities<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_identities<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ typedef absorbs_identities<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_total<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct is_total<icl::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;
+ typedef is_total<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = (Traits::is_total));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct type_to_string<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct type_to_string<icl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
static std::string apply()
{
@@ -206,7 +206,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/interval_base_set.hpp>
#include <boost/itl/interval_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief implements a set as a set of intervals - on insertion
@@ -64,10 +64,10 @@
typedef Alloc<DomainT> domain_allocator_type;
/// The corresponding atomized type representing this interval container of elements
- typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
+ typedef typename icl::set<DomainT,Compare,Alloc> atomized_type;
/// Container type for the implementation
- typedef typename itl::set<interval_type,ITL_EXCLUSIVE_LESS(interval_type),Alloc> ImplSetT;
+ typedef typename icl::set<interval_type,ITL_EXCLUSIVE_LESS(interval_type),Alloc> ImplSetT;
/// key type of the implementing container
typedef typename ImplSetT::key_type key_type;
@@ -168,23 +168,23 @@
// type traits
//-----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_set<icl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_set<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_set<icl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_interval_container<icl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_container<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_container<icl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
+struct is_interval_splitter<icl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
- typedef is_interval_splitter<itl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
+ typedef is_interval_splitter<icl::split_interval_set<DomainT,Compare,Interval,Alloc> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -192,14 +192,14 @@
// type representation
//-----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct type_to_string<itl::split_interval_set<DomainT,Compare,Interval,Alloc> >
+struct type_to_string<icl::split_interval_set<DomainT,Compare,Interval,Alloc> >
{
static std::string apply()
{ return "sp_itv_set<"+ type_to_string<DomainT>::apply() +">"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_ABSORBS_IDENTITIES_HPP_JOFA_081004
#define BOOST_ITL_TYPE_TRAITS_ABSORBS_IDENTITIES_HPP_JOFA_081004
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct absorbs_identities
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_ABSORBS_NEUTRONS_HPP_JOFA_081004
#define BOOST_ITL_TYPE_TRAITS_ABSORBS_NEUTRONS_HPP_JOFA_081004
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct absorbs_identities
{
Modified: sandbox/itl/boost/itl/type_traits/adds_inversely.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/adds_inversely.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/adds_inversely.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/itl/type_traits/has_inverse.hpp>
#include <boost/itl/functors.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type, class Combiner>
Modified: sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/mpl/bool.hpp>
#include <boost/itl/type_traits/no_type.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace detail
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_DIFFERENCE_HPP_JOFA_080911
#define BOOST_ITL_TYPE_TRAITS_DIFFERENCE_HPP_JOFA_080911
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct difference{ typedef Type type; };
Modified: sandbox/itl/boost/itl/type_traits/difference_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/difference_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/difference_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/no_type.hpp>
#include <boost/itl/type_traits/is_numeric.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//--------------------------------------------------------------------------
template<class Type>
Modified: sandbox/itl/boost/itl/type_traits/domain_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/domain_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/domain_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/bool.hpp>
#include <boost/itl/type_traits/no_type.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace detail
{
Modified: sandbox/itl/boost/itl/type_traits/element_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/element_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/element_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/bool.hpp>
#include <boost/itl/type_traits/no_type.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace detail
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_floating_point.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct has_inverse
Modified: sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/type_traits/codomain_type_of.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct has_set_semantics
{
Modified: sandbox/itl/boost/itl/type_traits/identity_element.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/identity_element.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/identity_element.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/type_to_string.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct identity_element
{
Modified: sandbox/itl/boost/itl/type_traits/infinity.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/infinity.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/infinity.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/is_numeric.hpp>
#include <boost/mpl/if.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
#ifdef BOOST_MSVC
Modified: sandbox/itl/boost/itl/type_traits/interval_type_default.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/interval_type_default.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/interval_type_default.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
#include <boost/itl/type_traits/is_continuous.hpp>
#include <boost/itl/type_traits/is_discrete.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
Modified: sandbox/itl/boost/itl/type_traits/interval_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/interval_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/interval_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/bool.hpp>
#include <boost/itl/type_traits/no_type.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace detail
{
Modified: sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/is_element_container.hpp>
#include <boost/itl/type_traits/is_set.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type>
struct is_assoc_element_container
Modified: sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/is_element_container.hpp>
#include <boost/itl/type_traits/is_set.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type>
struct is_associative_element_container
Modified: sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_asymmetric_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_asymmetric_interval
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/itl/type_traits/is_concept_equivalent.hpp>
#include <boost/itl/type_traits/is_interval_container.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class Type>
@@ -561,7 +561,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/mpl/and.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<template<class>class IsConcept, class LeftT, class RightT>
Modified: sandbox/itl/boost/itl/type_traits/is_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_container.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/itl/type_traits/segment_type_of.hpp>
#include <boost/itl/type_traits/is_map.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace detail
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/not.hpp>
#include <boost/itl/type_traits/is_discrete.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_continuous
{
Modified: sandbox/itl/boost/itl/type_traits/is_continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_continuous_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_continuous_interval
Modified: sandbox/itl/boost/itl/type_traits/is_discrete.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_discrete.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_discrete.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_floating_point.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_discrete
{
Modified: sandbox/itl/boost/itl/type_traits/is_discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_discrete_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/is_interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_discrete_interval
Modified: sandbox/itl/boost/itl/type_traits/is_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_element_container.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/type_traits/is_interval_container.hpp>
#include <boost/itl/type_traits/is_set.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type>
struct is_element_map
Modified: sandbox/itl/boost/itl/type_traits/is_icl_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_icl_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_icl_container.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/type_traits/is_interval_container.hpp>
#include <boost/itl/type_traits/is_set.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type>
struct is_icl_container
Modified: sandbox/itl/boost/itl/type_traits/is_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/itl/interval_bounds.hpp>
#include <boost/itl/interval_traits.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type>
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/not.hpp>
#include <boost/itl/type_traits/is_map.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_interval_container
{
Modified: sandbox/itl/boost/itl/type_traits/is_interval_joiner.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_joiner.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_joiner.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/config.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_interval_joiner
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_IS_INTERVAL_SEPARATOR_HPP_JOFA_081004
#define BOOST_ITL_TYPE_TRAITS_IS_INTERVAL_SEPARATOR_HPP_JOFA_081004
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_interval_separator
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/config.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_interval_splitter
{
Modified: sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/itl/type_traits/is_combinable.hpp>
#include <boost/itl/type_traits/is_container.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//--------------------------------------------------------------------------
namespace detail
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/config.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_map
{
Modified: sandbox/itl/boost/itl/type_traits/is_numeric.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_numeric.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_numeric.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <limits>
#include <complex>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_numeric
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/config.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_set
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_IS_TOTAL_HPP_JOFA_081004
#define BOOST_ITL_TYPE_TRAITS_IS_TOTAL_HPP_JOFA_081004
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct is_total
{
Modified: sandbox/itl/boost/itl/type_traits/no_type.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/no_type.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/no_type.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_NO_TYPE_HPP_JOFA_100902
#define BOOST_ITL_TYPE_TRAITS_NO_TYPE_HPP_JOFA_100902
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
struct no_type{};
Modified: sandbox/itl/boost/itl/type_traits/segment_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/segment_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/segment_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/bool.hpp>
#include <boost/itl/type_traits/no_type.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
namespace detail
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_SIZE_HPP_JOFA_080911
#define BOOST_ITL_TYPE_TRAITS_SIZE_HPP_JOFA_080911
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct size{ typedef std::size_t type; };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/size_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/size_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/size_type_of.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
#define BOOST_ITL_TYPE_TRAITS_SIZE_TYPE_OF_HPP_JOFA_080911
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct size_type_of{ typedef std::size_t type; };
}} // namespace boost itl
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_SUCC_PRED_HPP_JOFA_080913
#define BOOST_ITL_TYPE_TRAITS_SUCC_PRED_HPP_JOFA_080913
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class IncrementableT>
inline static IncrementableT succ(IncrementableT x) { return ++x; }
Modified: sandbox/itl/boost/itl/type_traits/to_string.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/to_string.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/to_string.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#include <string>
#include <sstream>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
/// Static class template for the string representation of values
Modified: sandbox/itl/boost/itl/type_traits/type_to_string.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/type_to_string.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/type_to_string.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/type_traits/is_float.hpp>
#include <boost/mpl/if.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
//--------------------------------------------------------------------------
template<class Type>
Modified: sandbox/itl/boost/itl/type_traits/unit_element.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/unit_element.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/unit_element.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/succ_pred.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <class Type> struct unit_element{ static Type value(); };
@@ -29,7 +29,7 @@
template <class Type>
inline Type unit_element<Type>::value()
- { return itl::succ(identity_element<Type>::value()); }
+ { return icl::succ(identity_element<Type>::value()); }
}} // namespace boost itl
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#ifndef BOOST_ITL_VALUE_SIZE_HPP_JOFA_081004
#define BOOST_ITL_VALUE_SIZE_HPP_JOFA_081004
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template <typename Type>
@@ -41,7 +41,7 @@
template <typename Type>
inline std::size_t value_size<Type>::apply(const Type& value)
-{ return itl::iterative_size(value); }
+{ return icl::iterative_size(value); }
Modified: sandbox/itl/boost/itl_xt/bits.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/bits.hpp (original)
+++ sandbox/itl/boost/itl_xt/bits.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#include <boost/itl/type_traits/has_set_semantics.hpp>
#include <boost/itl/detail/relation_state.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// A bit_range_type is supposed to cover the range of bits including endings.
@@ -127,7 +127,7 @@
typedef bits<nat64> bits64;
template<class NaturalT>
-int inclusion_compare(itl::bits<NaturalT> left, itl::bits<NaturalT> right)
+int inclusion_compare(icl::bits<NaturalT> left, icl::bits<NaturalT> right)
{
if(0 ==(left.word() & right.word())) return inclusion::unrelated;
else if(left.word() < right.word() ) return inclusion::subset;
@@ -147,7 +147,7 @@
template<class CharType, class CharTraits, class NaturalT>
std::basic_ostream<CharType, CharTraits>& operator <<
-(std::basic_ostream<CharType, CharTraits>& stream, const itl::bits<NaturalT>& object)
+(std::basic_ostream<CharType, CharTraits>& stream, const icl::bits<NaturalT>& object)
{
return stream << object.word();
}
@@ -241,13 +241,13 @@
};
-template <>struct type_to_string<itl::bits<unsigned char > >{static std::string apply(){ return "bit8"; }};
-template <>struct type_to_string<itl::bits<unsigned short> >{static std::string apply(){ return "bit16"; }};
-template <>struct type_to_string<itl::bits<unsigned int > >{static std::string apply(){ return "bit_32"; }};
-template <>struct type_to_string<itl::bits<unsigned long > >{static std::string apply(){ return "bit32"; }};
-template <>struct type_to_string<itl::bits<unsigned long long> >{static std::string apply(){ return "bit64"; }};
+template <>struct type_to_string<icl::bits<unsigned char > >{static std::string apply(){ return "bit8"; }};
+template <>struct type_to_string<icl::bits<unsigned short> >{static std::string apply(){ return "bit16"; }};
+template <>struct type_to_string<icl::bits<unsigned int > >{static std::string apply(){ return "bit_32"; }};
+template <>struct type_to_string<icl::bits<unsigned long > >{static std::string apply(){ return "bit32"; }};
+template <>struct type_to_string<icl::bits<unsigned long long> >{static std::string apply(){ return "bit64"; }};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_XT_BITS_HPP_JOFA_091023
Modified: sandbox/itl/boost/itl_xt/bits_gentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/bits_gentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/bits_gentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,15 +13,15 @@
#include <boost/itl_xt/numbergentor.hpp>
#include <boost/itl_xt/bits.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class NaturalT>
-class bits_gentor: public RandomGentorAT<itl::bits<NaturalT> >
+class bits_gentor: public RandomGentorAT<icl::bits<NaturalT> >
{
public:
- typedef typename itl::interval<NaturalT>::type range_type;
- typedef itl::bits<NaturalT> bits_type;
+ typedef typename icl::interval<NaturalT>::type range_type;
+ typedef icl::bits<NaturalT> bits_type;
void some(bits_type& value)
{
@@ -36,7 +36,7 @@
range_type _value_range;
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp (original)
+++ sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl_xt/bits.hpp>
#include <boost/mpl/not.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//------------------------------------------------------------------------------
@@ -125,7 +125,7 @@
next_bit();
if(_on_bit == past)
{ // The current bitset passed the end
- if(_reptator < pred(itl::length(_saltator->first)))
+ if(_reptator < pred(icl::length(_saltator->first)))
{
++_reptator;
_on_bit = ante;
@@ -157,7 +157,7 @@
--_saltator;
// NOW: decrement insecure, because _saltator can (finally) be
// begin here. increment and dereference are secure.
- _reptator = itl::length(_saltator->first);
+ _reptator = icl::length(_saltator->first);
--_reptator;
_on_bit = past;
}
@@ -205,7 +205,7 @@
if(_on_bit == beyond)
{
--_saltator;
- _reptator = itl::length(_saltator->first);
+ _reptator = icl::length(_saltator->first);
--_reptator;
_on_bit = Proceed::last_bit(_saltator->second.word());
}
@@ -510,7 +510,7 @@
} //namespace biterate
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_XT_DETAIL_BIT_ELEMENT_ITERATOR_HPP_JOFA_091109
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -32,7 +32,7 @@
#include <bitset>
#include <boost/itl/detail/notate.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
@@ -54,7 +54,7 @@
enum_bitset& add(int bit){this->set(bit); return *this;}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_ENUM_BITSET_HPP_JOFA_021204
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -33,7 +33,7 @@
#include <boost/itl/map.hpp>
#include <boost/itl_xt/episode_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// A collection (product) of episodes of different types that do not change for a period of time
@@ -88,10 +88,10 @@
*/
template <class TimeT, class TypeDomain>
-class episode_product : public boost::itl::map<typename TypeDomain::DomainET, episode_set<TimeT,TypeDomain> >
+class episode_product : public boost::icl::map<typename TypeDomain::DomainET, episode_set<TimeT,TypeDomain> >
{
public:
- typedef boost::itl::map<typename TypeDomain::DomainET, episode_set<TimeT,TypeDomain> > base_type;
+ typedef boost::icl::map<typename TypeDomain::DomainET, episode_set<TimeT,TypeDomain> > base_type;
typedef typename base_type::value_type value_type;
typedef typename base_type::data_type data_type;
typedef typename base_type::data_type EpisodeSetTD;
@@ -192,10 +192,10 @@
NOTE MEMO DESIGN USING PRIVATE INHERITENCE
template <class TimeT, class TypeDomain>
-class episode_product : private itl::MapT<TypeDomain::DomainET, episode_set<TimeT,TypeDomain> >
+class episode_product : private icl::MapT<TypeDomain::DomainET, episode_set<TimeT,TypeDomain> >
{
public:
- typedef itl::MapT<TypeDomain::DomainET, episode_set<TimeT,TypeDomain> > BaseTD;
+ typedef icl::MapT<TypeDomain::DomainET, episode_set<TimeT,TypeDomain> > BaseTD;
typedef BaseTD::value_type value_type;
typedef BaseTD::data_type data_type;
typedef BaseTD::data_type EpisodeSetTD;
@@ -290,7 +290,7 @@
}
*/
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_EPISODE_PRODUCT_HPP_HPP_JOFA_011005
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -34,7 +34,7 @@
#include <boost/itl/set.hpp>
#include <boost/itl_xt/typed_episode.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename EpisodePointer>
class Less_TypedEpisodeATP
@@ -67,7 +67,7 @@
@author Joachim Faulhaber
*/
template <class TimeT, class TypeDomain>
-class episode_set : public itl::set<typed_episode<TimeT, TypeDomain>*,
+class episode_set : public icl::set<typed_episode<TimeT, TypeDomain>*,
#ifdef ITL_USE_COMPARE_TEMPLATE_TEMPLATE
Less_TypedEpisodeATP
#else
@@ -78,7 +78,7 @@
// all elements must have the same type from TypeDomain
public:
typedef typed_episode<TimeT, TypeDomain>* episode_type;
- typedef itl::set<typed_episode<TimeT, TypeDomain>*,
+ typedef icl::set<typed_episode<TimeT, TypeDomain>*,
ITL_COMPARE_INSTANCE(Less_TypedEpisodeATP,episode_type)> base_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
@@ -129,7 +129,7 @@
return true;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_EPISODE_SET_HPP_HPP_JOFA_011015
Modified: sandbox/itl/boost/itl_xt/fixtupelconst.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/fixtupelconst.hpp (original)
+++ sandbox/itl/boost/itl_xt/fixtupelconst.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -34,14 +34,14 @@
#define FOREACH_VAR(idx) for(VarEnumTD idx=0; idx < varCountV; idx++)
#define FOREACH_VAR_TO(idx, upb) for(VarEnumTD idx=0; idx < upb; idx++)
-namespace boost{namespace itl
+namespace boost{namespace icl
{
typedef int VarEnumTD;
typedef int StatVarTD;
typedef int GroupVarTD;
const GroupVarTD UNDEFINED_GROUP = -1;
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_FIXTUPELCONSTT_HPP_JOFA_040621
Modified: sandbox/itl/boost/itl_xt/gentorit.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/gentorit.hpp (original)
+++ sandbox/itl/boost/itl_xt/gentorit.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -34,7 +34,7 @@
#include <boost/itl_xt/random.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class TypeT> class RandomGentorProfile{};
@@ -52,7 +52,7 @@
{
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -35,7 +35,7 @@
#include <boost/itl_xt/fixtupelconst.hpp>
#include <boost/itl/map.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <int VarCount> class var_tuple;
@@ -85,7 +85,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -34,7 +34,7 @@
#include <boost/itl_xt/group_order.hpp>
#include <boost/itl/map.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <int varCountV>
class grouping
@@ -54,7 +54,7 @@
};
template <int varCountV>
- itl::grouping<varCountV>::grouping ()
+ icl::grouping<varCountV>::grouping ()
{
FOREACH_VAR(idx)
m_GroupOrder[idx] = NULL;
@@ -62,14 +62,14 @@
template <int varCountV>
- itl::grouping<varCountV>::grouping (const grouping<varCountV>& src)
+ icl::grouping<varCountV>::grouping (const grouping<varCountV>& src)
{
FOREACH_VAR(idx)
m_GroupOrder[idx] = src.m_GroupOrder[idx];
}
template <int varCountV>
- grouping<varCountV>& itl::grouping<varCountV>::operator = (const grouping<varCountV>& src)
+ grouping<varCountV>& icl::grouping<varCountV>::operator = (const grouping<varCountV>& src)
{
if(&src != this)
{
@@ -80,7 +80,7 @@
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __grouping_JOFA_040621_H__
Modified: sandbox/itl/boost/itl_xt/interval_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/interval_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/interval_bitset.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -21,7 +21,7 @@
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief Large bitsets that combine interval compression and bitcompression.
@@ -29,19 +29,19 @@
Class interval_bitset implements a set as an interval_map of bitsets.
An interval_bitset is selfcompressing in two ways.
Large contiguous runs of bits can be represented by intervals in the
- same way as for itl::interval_set or itl::interval_map (interval compression).
+ same way as for icl::interval_set or icl::interval_map (interval compression).
Individual bits that spread over narrow ranges are represented in
machine words as bitsets (bit compression).
There is a datailed description on how an interval_bitset is
- implemented using itl::interval_map in the project section
+ implemented using icl::interval_map in the project section
of the boost book documentation here:
http://www.joachim-faulhaber.de/boost_itl/doc/libs/itl/doc/html/boost_itl/projects.html
*/
template
<
typename DomainT = unsigned long,
- typename BitSetT = itl::bits<unsigned long>,
+ typename BitSetT = icl::bits<unsigned long>,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, DomainT, Compare), //JODO change to right_open_interval
ITL_ALLOC Alloc = std::allocator
@@ -72,9 +72,9 @@
//segment element container
{
public:
- typedef boost::itl::interval_map
- <DomainT, BitSetT, boost::itl::partial_absorber,
- std::less, boost::itl::inplace_bit_add, boost::itl::inplace_bit_and> interval_bitmap_type;
+ typedef boost::icl::interval_map
+ <DomainT, BitSetT, boost::icl::partial_absorber,
+ std::less, boost::icl::inplace_bit_add, boost::icl::inplace_bit_and> interval_bitmap_type;
typedef DomainT domain_type;
typedef DomainT codomain_type;
@@ -92,7 +92,7 @@
typedef typename interval_bitmap_type::key_type key_type;
typedef typename interval_bitmap_type::value_type value_type;
- typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
+ typedef typename icl::set<DomainT,Compare,Alloc> atomized_type;
typedef typename interval_bitmap_type::iterator iterator;
typedef typename interval_bitmap_type::const_iterator const_iterator;
@@ -100,13 +100,13 @@
typedef typename interval_bitmap_type::const_reverse_iterator const_reverse_iterator;
/// element iterator: Depreciated, see documentation.
- typedef boost::itl::bit_element_iterator<iterator> element_iterator;
+ typedef boost::icl::bit_element_iterator<iterator> element_iterator;
/// element const iterator: Depreciated, see documentation.
- typedef boost::itl::bit_element_iterator<const_iterator> element_const_iterator;
+ typedef boost::icl::bit_element_iterator<const_iterator> element_const_iterator;
/// element reverse iterator: Depreciated, see documentation.
- typedef boost::itl::bit_element_iterator<reverse_iterator> element_reverse_iterator;
+ typedef boost::icl::bit_element_iterator<reverse_iterator> element_reverse_iterator;
/// element const reverse iterator: Depreciated, see documentation.
- typedef boost::itl::bit_element_iterator<const_reverse_iterator> element_const_reverse_iterator;
+ typedef boost::icl::bit_element_iterator<const_reverse_iterator> element_const_reverse_iterator;
typedef typename interval_bitmap_type::pointer pointer;
typedef typename interval_bitmap_type::const_pointer const_pointer;
@@ -148,8 +148,8 @@
interval_bitset& intersect(const element_type& rhs) {return segment_apply(&interval_bitset::intersect_,interval_type(rhs));}
interval_bitset& flip (const element_type& rhs) {return segment_apply(&interval_bitset::flip_, interval_type(rhs));}
- void clear() { itl::clear(_map); }
- bool empty()const { return itl::is_empty(_map); }
+ void clear() { icl::clear(_map); }
+ bool empty()const { return icl::is_empty(_map); }
size_type cardinality()const;
size_type size()const { return cardinality(); }
size_type interval_count()const { return interval_count(_map); }
@@ -157,8 +157,8 @@
bool contains(element_type element)const{ return _map(element>>shift).contains(element & mask); }
bool contains(const segment_type& segment)const;
- bool contains(const interval_bitset& sub)const { return itl::contains(_map, sub._map); }
- bool contained_in(const interval_bitset& super)const{ return itl::within(_map, super._map); }
+ bool contains(const interval_bitset& sub)const { return icl::contains(_map, sub._map); }
+ bool contained_in(const interval_bitset& super)const{ return icl::within(_map, super._map); }
void show_segments()const;
void show_matrix(const char off_on[2] = " 1")const;
@@ -246,7 +246,7 @@
#pragma warning(pop)
#endif
- typedef itl::bits<unsigned char> PartsT;
+ typedef icl::bits<unsigned char> PartsT;
enum { inner_part = 0, sub_part = 1, super_part = 2, inter_part = 4 };
typedef void (interval_bitset::*segment_combiner)(element_type, element_type, bitset_type);
@@ -380,7 +380,7 @@
{
size_type cardinality = 0;
ITL_const_FORALL(typename interval_bitmap_type, it_, _map)
- cardinality += (it_->second.cardinality() * itl::cardinality(it_->first));
+ cardinality += (it_->second.cardinality() * icl::cardinality(it_->first));
return cardinality;
}
@@ -514,7 +514,7 @@
// type representation
//-----------------------------------------------------------------------------
template <class DomainT, class BitSetT, ITL_COMPARE Compare, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
-struct type_to_string<itl::interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc> >
+struct type_to_string<icl::interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc> >
{
static std::string apply()
{
@@ -526,9 +526,9 @@
namespace segmental
{
template <typename DomainT, typename BitSetT>
- struct atomizer<itl::set<DomainT>, interval_bitset<DomainT, BitSetT> >
+ struct atomizer<icl::set<DomainT>, interval_bitset<DomainT, BitSetT> >
{
- void operator()( itl::set<DomainT>& atomized,
+ void operator()( icl::set<DomainT>& atomized,
const interval_bitset<DomainT, BitSetT>& clustered)
{
typedef interval_bitset<DomainT, BitSetT> InterBitsetT;
@@ -541,7 +541,7 @@
} // namespace segmental
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_XT_INTERVAL_BITSET_HPP_JOFA_091023
Modified: sandbox/itl/boost/itl_xt/itvgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/itvgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/itvgentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -39,14 +39,14 @@
#include <boost/itl_xt/numbergentor.hpp>
#include <boost/itl_xt/seqgentor.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
-template <class ItvDomTV, class ItvTV=itl::interval<ItvDomTV>::type>
+template <class ItvDomTV, class ItvTV=icl::interval<ItvDomTV>::type>
class ItvGentorT: public RandomGentorAT<ItvTV>
{
public:
- typedef typename itl::interval<ItvDomTV>::type range_type;
+ typedef typename icl::interval<ItvDomTV>::type range_type;
virtual void some(ItvTV& x);
@@ -55,7 +55,7 @@
void setValueRange(ItvDomTV low, ItvDomTV up)
{
- m_valueRange = itl::construct<range_type>(low, up);
+ m_valueRange = icl::construct<range_type>(low, up);
}
void setMaxIntervalLength(ItvDomTV len) { m_maxIntervalLength=len; }
@@ -100,7 +100,7 @@
{
NumberGentorT<unsigned> NATGentor;
ItvDomTV x1 = m_ItvDomTVGentor(m_valueRange);
- itl::bound_type bndTypes = NATGentor(4);
+ icl::bound_type bndTypes = NATGentor(4);
unsigned upOrDown = NATGentor(1);
unsigned decideEmpty = NATGentor(2);
@@ -123,7 +123,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl_xt/list.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/list.hpp (original)
+++ sandbox/itl/boost/itl_xt/list.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -8,7 +8,7 @@
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
-class itl::list
+class icl::list
a general list class that extends stl-lists
for concepts InplaceAddable and InplaceSubtractable
--------------------------------------------------------------------*/
@@ -26,7 +26,7 @@
#include <boost/itl/predicates.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//JODO 1_0_1 documentation
/// an stl based list implementing inplace addition operators +=
@@ -42,7 +42,7 @@
typedef Alloc<DataT> allocator_type;
private:
- typedef typename itl::list<DataT, Alloc> type;
+ typedef typename icl::list<DataT, Alloc> type;
typedef typename std::list<DataT, allocator_type> base_type;
public:
@@ -200,24 +200,24 @@
template <typename DataT, ITL_ALLOC Alloc>
- inline bool operator == (const itl::list<DataT,Alloc>& lhs,
- const itl::list<DataT,Alloc>& rhs)
+ inline bool operator == (const icl::list<DataT,Alloc>& lhs,
+ const icl::list<DataT,Alloc>& rhs)
{
typedef std::list<DataT,Alloc<DataT> > base_type;
return operator==((const base_type&)lhs, (const base_type&)rhs);
}
template <typename DataT, ITL_ALLOC Alloc>
- inline bool operator < (const itl::list<DataT,Alloc>& lhs,
- const itl::list<DataT,Alloc>& rhs)
+ inline bool operator < (const icl::list<DataT,Alloc>& lhs,
+ const icl::list<DataT,Alloc>& rhs)
{
typedef std::list<DataT,Alloc<DataT> > base_type;
return operator<((const base_type&)lhs, (const base_type&)rhs);
}
template <typename DataT, ITL_ALLOC Alloc>
- inline bool operator <= (const itl::list<DataT,Alloc>& lhs,
- const itl::list<DataT,Alloc>& rhs)
+ inline bool operator <= (const icl::list<DataT,Alloc>& lhs,
+ const icl::list<DataT,Alloc>& rhs)
{
typedef std::list<DataT,Alloc<DataT> > base_type;
return operator<=((const base_type&)lhs, (const base_type&)rhs);
@@ -429,9 +429,9 @@
class DataT, ITL_ALLOC Alloc>
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream,
- const itl::list<DataT,Alloc>& object)
+ const icl::list<DataT,Alloc>& object)
{
- typedef itl::list<DataT,Alloc> ObjectT;
+ typedef icl::list<DataT,Alloc> ObjectT;
stream << "[";
typename ObjectT::const_iterator it = object.begin();
if(it != object.end())
@@ -445,13 +445,13 @@
// type traits
//-----------------------------------------------------------------------------
template <class Type>
-struct type_to_string<itl::list<Type> >
+struct type_to_string<icl::list<Type> >
{
static std::string apply()
{ return "list<"+ type_to_string<Type>::apply() +">"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_LIST_HPP_JOFA_070519
Modified: sandbox/itl/boost/itl_xt/map_segment_gentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/map_segment_gentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/map_segment_gentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,19 +16,19 @@
#include <boost/itl_xt/itvgentor.hpp>
#include <boost/itl_xt/seqgentor.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
-template <class DomainT, class CodomainT, class IntervalT = itl::interval<DomainT>::type >
+template <class DomainT, class CodomainT, class IntervalT = icl::interval<DomainT>::type >
class map_segment_gentor: public RandomGentorAT<std::pair<IntervalT, CodomainT> >
{
public:
typedef DomainT domain_type;
typedef CodomainT codomain_type;
typedef IntervalT interval_type;
- typedef typename itl::interval<domain_type>::type range_type;
- typedef typename itl::interval<codomain_type>::type co_range_type;
- //typedef typename itl::interval<codomain_type>::type co_range_type;
+ typedef typename icl::interval<domain_type>::type range_type;
+ typedef typename icl::interval<codomain_type>::type co_range_type;
+ //typedef typename icl::interval<codomain_type>::type co_range_type;
typedef std::pair<IntervalT, CodomainT> segment_type;
public:
Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl_xt/list.hpp>
#include <boost/itl_xt/gentorit.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class MapTV>
@@ -23,7 +23,7 @@
typedef typename MapTV::key_type DomainTD;
typedef typename MapTV::data_type CodomainTD;
typedef list<ValueTypeTD> SampleTypeTD;
- typedef typename itl::interval<int>::type sample_range_type;
+ typedef typename icl::interval<int>::type sample_range_type;
MapGentorT(): p_domainGentor(NULL), p_codomainGentor(NULL) {}
~MapGentorT() { delete p_domainGentor; delete p_codomainGentor; }
@@ -44,11 +44,11 @@
}
void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = itl::interval<int>::right_open(lwb,upb); }
+ { m_sampleSizeRange = icl::interval<int>::right_open(lwb,upb); }
- void setRangeOfSampleSize(const itl::interval<int>::type& szRange)
+ void setRangeOfSampleSize(const icl::interval<int>::type& szRange)
{
- BOOST_ASSERT(itl::bounds(szRange) == interval_bounds::right_open());
+ BOOST_ASSERT(icl::bounds(szRange) == interval_bounds::right_open());
m_sampleSizeRange = szRange;
}
@@ -65,7 +65,7 @@
void MapGentorT<MapTV>::some(MapTV& x)
{
NumberGentorT<int> intGentor;
- itl::clear(x);
+ icl::clear(x);
m_sample.clear();
m_sampleSize = intGentor(m_sampleSizeRange);
@@ -128,7 +128,7 @@
}
*/
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_XT_MAPGENTOR_HPP_JOFA_000724
Modified: sandbox/itl/boost/itl_xt/meta_log.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/meta_log.hpp (original)
+++ sandbox/itl/boost/itl_xt/meta_log.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -9,7 +9,7 @@
#ifndef BOOST_ITL_XT_META_LOG_HPP_JOFA_091023
#define BOOST_ITL_XT_META_LOG_HPP_JOFA_091023
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// A meta implementation of an the logarithm function on integrals
@@ -25,6 +25,6 @@
template <size_t Argument>
struct power2_{ enum { value = 1 << Argument }; };
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_XT_META_LOG_HPP_JOFA_091023
Modified: sandbox/itl/boost/itl_xt/numbergentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/numbergentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/numbergentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
#include <boost/itl/type_traits/interval_type_default.hpp>
#include <boost/itl_xt/gentorit.hpp>
-using namespace boost::itl;
+using namespace boost::icl;
#define RND_1_TO(y) (1+(int)((double)(y)*rand()/(RAND_MAX+1.0)))
#define RND_0_TO(y) ((int)((double)((y)+1)*rand()/(RAND_MAX+1.0)))
@@ -31,7 +31,7 @@
#define RND_WITHIN_EXUPB(x,y) ((x)+((double)((y)-(x))*rand()/(RAND_MAX+1.0)))
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class NumTV>
@@ -56,7 +56,7 @@
class NumberGentorProfile : public RandomGentorProfile<NumT>
{
public:
- typedef typename itl::interval<NumT>::type range_type;
+ typedef typename icl::interval<NumT>::type range_type;
private:
range_type _range;
};
@@ -65,7 +65,7 @@
class NumberGentorT : public RandomGentorAT<NumTV>
{
public:
- typedef typename itl::interval<NumTV>::type range_type;
+ typedef typename icl::interval<NumTV>::type range_type;
public:
NumberGentorT():
m_valueRange( NumTV(), unit_element<NumTV>::value() ) {}
@@ -74,16 +74,16 @@
NumTV operator() (NumTV lwb, NumTV upb) { return rnd_within_exUpb<NumTV>(lwb,upb); }
NumTV operator() (range_type rng)
{
- BOOST_ASSERT( itl::bounds(rng) == interval_bounds::right_open()
- || itl::bounds(rng) == interval_bounds::closed());
- if(itl::bounds(rng) == interval_bounds::right_open())
+ BOOST_ASSERT( icl::bounds(rng) == interval_bounds::right_open()
+ || icl::bounds(rng) == interval_bounds::closed());
+ if(icl::bounds(rng) == interval_bounds::right_open())
return rnd_within_exUpb<NumTV>(rng.lower(), rng.upper());
else
return rnd_within<NumTV>(rng.lower(), rng.upper());
}
void setRange(range_type rng) { m_valueRange = rng; }
- void setRange(NumTV lwb, NumTV upb) { m_valueRange = itl::interval<NumTV>::right_open(lwb,upb); }
+ void setRange(NumTV lwb, NumTV upb) { m_valueRange = icl::interval<NumTV>::right_open(lwb,upb); }
void calibrate(const RandomGentorProfile<NumTV>& profile)
{
@@ -253,7 +253,7 @@
return message;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __NUMBERGENTORT_H_JOFA_000725__
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -32,7 +32,7 @@
#include <string>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// an enumeration ordered class type
@@ -140,7 +140,7 @@
//virtual bool isValueLess(const ordered_type<TypeDomain>* x2)const=0;
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -30,7 +30,7 @@
#include <stdafx.h>
#include "prefix_set.h"
-using namespace boost::itl;
+using namespace boost::icl;
int prefix_set::compareStrings(int& comSize, const char* s1, const char* s2)
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -33,7 +33,7 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/string_set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename StringT>
@@ -108,7 +108,7 @@
return compareResult == -1;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_PREFIX_SET_HPP_JOFA_040902
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/interval_map.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// Adds episodes of different types into a single history of episode_products
@@ -74,7 +74,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -35,7 +35,7 @@
#include <boost/itl/type_traits/interval_type_default.hpp>
#include <boost/itl/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class random
@@ -59,9 +59,9 @@
return some + lwb;
}
- unsigned rnd(const itl::interval<unsigned>::type& rng)
+ unsigned rnd(const icl::interval<unsigned>::type& rng)
{
- BOOST_ASSERT(itl::bounds(rng) == interval_bounds::right_open());
+ BOOST_ASSERT(icl::bounds(rng) == interval_bounds::right_open());
return rnd(rng.lower(),rng.upper());
}
@@ -69,7 +69,7 @@
//JODO subtractive_rng m_random;
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl_xt/randomnumber.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/randomnumber.hpp (original)
+++ sandbox/itl/boost/itl_xt/randomnumber.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -31,7 +31,7 @@
#include <functional>
#include <boost/itl/random.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class NumTV>
Modified: sandbox/itl/boost/itl_xt/seqgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/seqgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/seqgentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -35,7 +35,7 @@
#include <boost/itl_xt/gentorit.hpp>
#include <boost/itl_xt/list.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class SeqTV>
@@ -45,7 +45,7 @@
typedef typename SeqTV::value_type ValueTypeTD;
typedef typename SeqTV::value_type DomainTD;
typedef list<ValueTypeTD> SampleTypeTD;
- typedef typename itl::interval<int>::type sample_range_type;
+ typedef typename icl::interval<int>::type sample_range_type;
SeqGentorT(): p_domainGentor(NULL), m_unique(false){}
~SeqGentorT(){ delete p_domainGentor; }
@@ -61,10 +61,10 @@
}
void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = itl::interval<int>::right_open(lwb,upb); }
- void setRangeOfSampleSize(const itl::interval<int>::type& szRange)
+ { m_sampleSizeRange = icl::interval<int>::right_open(lwb,upb); }
+ void setRangeOfSampleSize(const icl::interval<int>::type& szRange)
{
- BOOST_ASSERT(itl::bounds(szRange) == interval_bounds::right_open());
+ BOOST_ASSERT(icl::bounds(szRange) == interval_bounds::right_open());
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -36,7 +36,7 @@
#include <boost/itl_xt/numbergentor.hpp>
#include <boost/itl_xt/list.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class SetTV>
@@ -48,7 +48,7 @@
typedef list<ValueTypeTD> SampleTypeTD;
typedef RandomGentorAT<DomainTD> DomainGentorT;
typedef DomainGentorT* DomainGentorPT;
- typedef typename itl::interval<int>::type sample_range_type;
+ typedef typename icl::interval<int>::type sample_range_type;
SetGentorT(): p_domainGentor(NULL) {}
~SetGentorT() { delete p_domainGentor; }
@@ -65,9 +65,9 @@
void setRangeOfSampleSize(int lwb, int upb)
{ m_sampleSizeRange = _interval<int>::right_open(lwb,upb); }
- void setRangeOfSampleSize(const itl::interval<int>::type& szRange)
+ void setRangeOfSampleSize(const icl::interval<int>::type& szRange)
{
- BOOST_ASSERT(itl::bounds(szRange) == interval_bounds::right_open());
+ BOOST_ASSERT(icl::bounds(szRange) == interval_bounds::right_open());
m_sampleSizeRange = szRange;
}
@@ -85,7 +85,7 @@
void SetGentorT<SetTV>::some(SetTV& x)
{
NumberGentorT<int> intGentor;
- itl::clear(x);
+ icl::clear(x);
m_sample.clear();
m_sampleSize = intGentor(m_sampleSizeRange);
@@ -146,7 +146,7 @@
}
*/
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/boost/itl_xt/statvardesct.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/statvardesct.hpp (original)
+++ sandbox/itl/boost/itl_xt/statvardesct.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -29,7 +29,7 @@
#define __StatVarDescT_JOFA_040614_H__
#include <boost/itl_xt/enum_bitset.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// Skalenniveau der Skala
@@ -76,7 +76,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __StatVarDescT_JOFA_040614_H__
Modified: sandbox/itl/boost/itl_xt/std/pair.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/std/pair.hpp (original)
+++ sandbox/itl/boost/itl_xt/std/pair.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -27,13 +27,13 @@
} //namespace std
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<>
inline std::string binary_template_to_string<std::pair>::apply() { return "p"; }
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_XT_STD_PAIR_HPP_JOFA_091006
Modified: sandbox/itl/boost/itl_xt/std/pair_gentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/std/pair_gentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/std/pair_gentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl_xt/std/pair.hpp>
#include <boost/itl_xt/gentorit.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
@@ -50,7 +50,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -33,7 +33,7 @@
#include <boost/itl/string_list.hpp>
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
string_list::string_list(const char* const deno[], int nOfDeno): list<std::string>()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -28,7 +28,7 @@
DEALINGS IN THE SOFTWARE.
+-----------------------------------------------------------------------------*/
/* ------------------------------------------------------------------
-class itl::string_list
+class icl::string_list
A List of Strings.
Can be useful for string split and join.
Also simple text-formating can be done.
@@ -41,7 +41,7 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/itl_list.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// providing split, join and basic text processing
@@ -50,7 +50,7 @@
@author Joachim Faulhaber
*/
-class string_list: public itl::list<std::string> //JODO URG no inhertiance from base container
+class string_list: public icl::list<std::string> //JODO URG no inhertiance from base container
{
public:
/** Empty string_list (default-Ctor) */
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -32,7 +32,7 @@
#include <boost/itl/map.hpp>
#include <string>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class CodomTV, class CompTV=less<std::string> >
class string_map : public MapT<std::string, CodomTV, CompTV>
@@ -50,7 +50,7 @@
// A template map class that's keys are handled case insensitive
template <class CodomTV>
- class ICstring_map : public itl::string_map<CodomTV, string_ICLess>
+ class ICstring_map : public icl::string_map<CodomTV, string_ICLess>
{
};
}} // namespace boost itl
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -35,7 +35,7 @@
#include <string.h>
#include <boost/itl/set.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
typedef std::string StringTD;
typedef StringTD (StringTD::* StringSelectorFPD)()const;
@@ -58,10 +58,10 @@
// ---------------------------------------------------------------------------------
template <ITL_COMPARE Compare = std::less>
- class string_set: public itl::set<std::string, Compare>
+ class string_set: public icl::set<std::string, Compare>
{
public:
- typedef itl::set<std::string, Compare> base_type;
+ typedef icl::set<std::string, Compare> base_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -29,7 +29,7 @@
#include "string_sheet.h"
#include <boost/itl/type_traits/to_string.hpp>
-using namespace boost::itl;
+using namespace boost::icl;
string diff_desc::afxReport(const string& file)const
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -33,7 +33,7 @@
#include <boost/itl/string_list.hpp>
#include <boost/itl/detail/notate.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
const int MAX_INPUT_ROW_SIZE = 10000;
@@ -82,7 +82,7 @@
void fprint(FILE* file, const char* sep = "\t")const;
void fscan(std::ifstream& ifstr, const char* sep = "\t");
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_STRING_SHEET_HPP_JOFA_050209
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -31,7 +31,7 @@
#define BOOST_ITL_STRINGPATTERN_SET_HPP_JOFA_040902
#include "prefix_set.h"
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// Specifies a set of strings via prefix_set s include and exclude
/** stringpattern_set repraesentiert eine Menge von Strings durch
@@ -65,7 +65,7 @@
prefix_set m_Excludes;
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_STRINGPATTERN_SET_HPP_JOFA_040902
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl_xt/var_tuple_order.hpp>
#include <boost/itl/split_interval_map.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <int VarCount>
@@ -22,7 +22,7 @@
public:
typedef var_tuple<VarCount> var_tuple_type;
typedef var_tuple_order<var_tuple_type> tuple_order_type;
- typedef itl::set<var_tuple_type, var_tuple_order> tuple_set_type;
+ typedef icl::set<var_tuple_type, var_tuple_order> tuple_set_type;
public:
virtual ~tuple_computer_interface(){};
@@ -72,7 +72,7 @@
typedef var_tuple<VarCount> var_tuple_type;
typedef var_tuple_order<var_tuple_type> tuple_order_type;
/// Container type for the implementation
- typedef itl::map<var_tuple_type, CounterT, partial_absorber, var_tuple_order> ImplMapTD;
+ typedef icl::map<var_tuple_type, CounterT, partial_absorber, var_tuple_order> ImplMapTD;
/// iterator
typedef typename ImplMapTD::iterator iterator;
/// const_iterator
@@ -305,14 +305,14 @@
*/
template <int VarCount, class TimeT, class CounteeT>
class date_tuple_computer :
- public tuple_computer_base<VarCount, itl::map<TimeT, CounteeT> >
+ public tuple_computer_base<VarCount, icl::map<TimeT, CounteeT> >
{
public:
- typedef typename itl::map<TimeT, CounteeT> counter_type;
+ typedef typename icl::map<TimeT, CounteeT> counter_type;
typedef tuple_computer_base<VarCount, counter_type> base_type;
typedef typename base_type::var_tuple_type var_tuple_type;
typedef typename base_type::key_compare key_compare;
- typedef typename itl::set<var_tuple_type, var_tuple_order> tuple_set_type;
+ typedef typename icl::set<var_tuple_type, var_tuple_order> tuple_set_type;
public:
// Default Ctor
@@ -364,11 +364,11 @@
typedef tuple_computer_base<VarCount, counter_type> base_type;
typedef typename base_type::var_tuple_type var_tuple_type;
typedef typename base_type::key_compare key_compare;
- typedef itl::set<var_tuple_type, var_tuple_order> tuple_set_type;
+ typedef icl::set<var_tuple_type, var_tuple_order> tuple_set_type;
typedef typename base_type::counter_type::interval_type interval_type;
private:
- typedef itl::map<TimeT, CounteeT> DateMapTD;
+ typedef icl::map<TimeT, CounteeT> DateMapTD;
public:
// Default Ctor
@@ -424,9 +424,9 @@
//JODO: Where to put this kind of functionality
template <class SubType, class ItvDomTV, class CodomTV>
void intervalize(interval_base_map<SubType, ItvDomTV, CodomTV>& itvMap,
- const itl::map<ItvDomTV, CodomTV>& dateMap)
+ const icl::map<ItvDomTV, CodomTV>& dateMap)
{
- typedef itl::map<ItvDomTV, CodomTV> DateMapTD;
+ typedef icl::map<ItvDomTV, CodomTV> DateMapTD;
typedef interval_base_map<SubType, ItvDomTV, CodomTV> ItvMapTD;
itvMap.clear();
@@ -469,7 +469,7 @@
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -35,7 +35,7 @@
#include <boost/itl/right_open_interval.hpp>
#include <boost/itl_xt/ordered_type.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// Serves as a base class for the decomposition of histories in episodes
@@ -55,7 +55,7 @@
virtual ~episode_interface(){}
/// das Intervall der Episode
- //virtual itl::interval<TimeT> interval()const=0; //JODO make IntervalT a template param
+ //virtual icl::interval<TimeT> interval()const=0; //JODO make IntervalT a template param
virtual right_open_interval<TimeT> interval()const=0;
};
@@ -74,7 +74,7 @@
{
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_TYPED_EPISODE_HPP_HPP_JOFA_011015
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -32,14 +32,14 @@
#include <boost/itl_xt/fixtupelconst.hpp>
#include <boost/itl_xt/list.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <int varCountV>
class var_permutation
{
public:
- typedef itl::list<VarEnumTD> ListTD;
+ typedef icl::list<VarEnumTD> ListTD;
public:
var_permutation(): m_Size(0) {}
var_permutation(const var_permutation&);
@@ -220,7 +220,7 @@
template <int varCountV>
- typename itl::var_permutation<varCountV>::ListTD var_permutation<varCountV>::asList()const
+ typename icl::var_permutation<varCountV>::ListTD var_permutation<varCountV>::asList()const
{
ListTD seq;
int idx = 0;
@@ -261,7 +261,7 @@
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -36,7 +36,7 @@
#include <string>
#include <sstream>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/// tuple of independent variables
/** class var_tuple: Die Tupel unabhängiger Variablen. Beschreiben
@@ -91,14 +91,14 @@
template <int varCountV>
- itl::var_tuple<varCountV>::var_tuple (StatVarTD val) // vor VC8: itl::var_tuple<varCountV>::var_tuple<varCountV>(StatVarTD val)
+ icl::var_tuple<varCountV>::var_tuple (StatVarTD val) // vor VC8: icl::var_tuple<varCountV>::var_tuple<varCountV>(StatVarTD val)
{
FOREACH_VAR(idx)
m_tupel[idx] = val;
}
template <int varCountV>
- itl::var_tuple<varCountV>::var_tuple (const var_tuple<varCountV>& src)
+ icl::var_tuple<varCountV>::var_tuple (const var_tuple<varCountV>& src)
{
FOREACH_VAR(idx)
m_tupel[idx] = src.m_tupel[idx];
@@ -172,7 +172,7 @@
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -33,7 +33,7 @@
#include <boost/itl/var_permutation.hpp>
#include <boost/itl/var_tuple.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
@@ -84,7 +84,7 @@
OmissionMapTD m_Omissions;
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -37,7 +37,7 @@
#include <boost/itl_xt/var_permutation.hpp>
#include <boost/itl_xt/grouping.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// template <typename VarTupleT> class var_permutation {};
@@ -79,19 +79,19 @@
};
template <typename VarTupleT>
- itl::var_tuple_order<VarTupleT>::var_tuple_order ()
+ icl::var_tuple_order<VarTupleT>::var_tuple_order ()
{
m_Permutation.setIdentity();
}
template <typename VarTupleT>
- itl::var_tuple_order<VarTupleT>::var_tuple_order (const var_tuple_order& order, const var_permutationT& perm):
+ icl::var_tuple_order<VarTupleT>::var_tuple_order (const var_tuple_order& order, const var_permutationT& perm):
m_Grouping(order.m_Grouping), m_Permutation(perm)
{}
template <typename VarTupleT>
- bool itl::var_tuple_order<VarTupleT>::operator() (const VarTupleT& x1, const VarTupleT& x2)const
+ bool icl::var_tuple_order<VarTupleT>::operator() (const VarTupleT& x1, const VarTupleT& x2)const
{
ITL_FORALL_VEC(permIdx, m_Permutation)
{
@@ -123,7 +123,7 @@
}
template <typename VarTupleT>
- VarEnumTD itl::var_tuple_order<VarTupleT>::indexOfFirstDifference(const VarTupleT& x1, const VarTupleT& x2)const
+ VarEnumTD icl::var_tuple_order<VarTupleT>::indexOfFirstDifference(const VarTupleT& x1, const VarTupleT& x2)const
{
ITL_FORALL_VEC(permIdx, m_Permutation)
{
@@ -154,7 +154,7 @@
return UNDEFINED_INDEX;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __var_tuple_order_JOFA_040620_H__
Modified: sandbox/itl/boost/validate/driver/abelian_monoid_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/abelian_monoid_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/abelian_monoid_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class abelian_monoid_driver : public itl_driver
{
@@ -63,8 +63,8 @@
{
case RootType::itl_set: {
switch(domainChoice) {
- case DomainType::Int: return new abelian_monoid_validater<itl::set<int> >;
- case DomainType::Double: return new abelian_monoid_validater<itl::set<double> >;
+ case DomainType::Int: return new abelian_monoid_validater<icl::set<int> >;
+ case DomainType::Double: return new abelian_monoid_validater<icl::set<double> >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_set: domainChoice:\n"),
domainChoice, _domainChoice);
}
@@ -90,6 +90,6 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_ABELIAN_MONOID_DRIVER_HPP_JOFA_100502
Modified: sandbox/itl/boost/validate/driver/bit_collector_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/bit_collector_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/bit_collector_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class bit_collector_driver : public itl_driver
@@ -103,9 +103,9 @@
case RootType::itl_map: {
switch(identityHandlerChoice) {
case IdentityHandlerType::partial_absorber:
- return new collector_validater< itl::map<int, itl::bits8, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
+ return new collector_validater< icl::map<int, icl::bits8, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
case IdentityHandlerType::partial_enricher:
- return new collector_validater< itl::map<int, itl::bits32, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
+ return new collector_validater< icl::map<int, icl::bits32, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case itl_map
@@ -113,9 +113,9 @@
case RootType::interval_map: {
switch(identityHandlerChoice) {
case IdentityHandlerType::partial_absorber:
- return new collector_validater<interval_map<int, itl::bits64, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
+ return new collector_validater<interval_map<int, icl::bits64, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
case IdentityHandlerType::partial_enricher:
- return new collector_validater<interval_map<int, itl::bits16, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
+ return new collector_validater<interval_map<int, icl::bits16, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case interval_map
@@ -123,9 +123,9 @@
case RootType::split_interval_map: {
switch(identityHandlerChoice) {
case IdentityHandlerType::partial_absorber:
- return new collector_validater<split_interval_map<int, itl::bits32, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
+ return new collector_validater<split_interval_map<int, icl::bits32, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
case IdentityHandlerType::partial_enricher:
- return new collector_validater<split_interval_map<double, itl::bits8, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
+ return new collector_validater<split_interval_map<double, icl::bits8, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case split_interval_map
@@ -139,6 +139,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_BIT_COLLECTOR_DRIVER_HPP_JOFA_091009
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class collector_driver : public itl_driver
@@ -103,9 +103,9 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new collector_validater<itl::map<int,std::set<int> > >;
- case IdentityHandlerType::partial_enricher: return new collector_validater<itl::map<int,std::set<int>,partial_enricher> >;
- //case IdentityHandlerType::total_absorber : return new collector_validater<itl::map<int,std::set<int>,total_absorber > >;
+ case IdentityHandlerType::partial_absorber: return new collector_validater<icl::map<int,std::set<int> > >;
+ case IdentityHandlerType::partial_enricher: return new collector_validater<icl::map<int,std::set<int>,partial_enricher> >;
+ //case IdentityHandlerType::total_absorber : return new collector_validater<icl::map<int,std::set<int>,total_absorber > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case itl_map
@@ -137,6 +137,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_COLLECTOR_DRIVER_HPP_JOFA_091009
Modified: sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class interval_bitset_driver : public itl_driver
@@ -71,6 +71,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_INTERVAL_BITSET_DRIVER_HPP_JOFA_091027
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -22,7 +22,7 @@
#pragma warning(disable:4996) // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
namespace RootType
{
@@ -108,7 +108,7 @@
if(_info_level >= inform::rarely)
reportFrequencies();
- return itl::is_empty(_violationsCount);
+ return icl::is_empty(_violationsCount);
}
void validateType()
@@ -157,12 +157,12 @@
std::cout << "------------------------------------------------------------------------------" << std::endl;
// Summary for the current cycle
- double avg_evaluation_time_per_law = avg_evaluation_time/itl::size(_frequencies);
+ double avg_evaluation_time_per_law = avg_evaluation_time/icl::size(_frequencies);
printf( " %10.3lf%-53s%7ld%7.0lf\n",
avg_evaluation_time_per_law, " total avg of atomic evaluation (micro sec)", instance_count, avg_evaluation_time_per_law);
int violation_count = 1;
- if(!itl::is_empty(_violations))
+ if(!icl::is_empty(_violations))
{
std::cout << "------------------------------------------------------------------------------" << std::endl;
std::cout << "--- Law violations -----------------------------------------------count-------" << std::endl;
@@ -172,14 +172,14 @@
printf("%3d %-59s%8d\n", violation_count, it->first.c_str(), it->second.getViolationsCount());
violation_count++;
}
- if(!itl::is_empty(_violations))
+ if(!icl::is_empty(_violations))
std::cout << "------------------------------------------------------------------------------" << std::endl;
ITL_FORALL(ViolationMapT, it, _violations)
{
PolyLawViolations violas = it->second;
violas.reportFirst();
}
- if(!itl::is_empty(_violations))
+ if(!icl::is_empty(_violations))
std::cout << "------------------------------------------------------------------------------" << std::endl;
}
@@ -270,7 +270,7 @@
return true;
else if(_required_law_count == 0 || _required_law_validation_count == 0)
return false; // If counts are not limited: Run for ever.
- else if(itl::size(_frequencies) < static_cast<size_t>(_required_law_count))
+ else if(icl::size(_frequencies) < static_cast<size_t>(_required_law_count))
return false; // Not yet reached all laws
else
// All laws reached. Enough validation cycles for every law?
@@ -301,7 +301,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#ifdef BOOST_MSVC
#pragma warning(pop)
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/validater/interval_morphic_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class itl_morphic_driver : public itl_driver
@@ -136,5 +136,5 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/driver/itl_relations_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_relations_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_relations_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class itl_relations_driver : public itl_driver
@@ -167,5 +167,5 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class itl_set_driver : public itl_driver
@@ -106,6 +106,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_ITL_SET_DRIVER_HPP_JOFA_080405
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class Law>
@@ -170,7 +170,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SINGLE_LAW_DRIVER_HPP_JOFA_080405
Modified: sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class map_copy_conformity_driver : public itl_driver
@@ -94,8 +94,8 @@
concept_validater* chooseValidater()
{
- typedef itl::interval<double>::type interval_double;
- typedef itl::interval<int>::type interval_int;
+ typedef icl::interval<double>::type interval_double;
+ typedef icl::interval<int>::type interval_int;
int rootChoice = _rootChoice.some();
int identityHandlerChoice = _identityHandlerChoice.some();
@@ -105,30 +105,30 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_absorber > >;
- case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<icl::list<std::pair<int,int> >, icl::map<int,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<icl::list<std::pair<int,int> >, icl::map<int,int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<icl::list<std::pair<int,int> >, icl::map<int,int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<icl::list<std::pair<int,int> >, icl::map<int,int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case itl_map
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, interval_map<double,int,partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, interval_map<double,int,partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, interval_map<int, int,total_absorber > >;
- case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, interval_map<int, int,total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<icl::list<std::pair<interval_double,int> >, interval_map<double,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<icl::list<std::pair<interval_double,int> >, interval_map<double,int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<icl::list<std::pair<interval_int, int> >, interval_map<int, int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<icl::list<std::pair<interval_int, int> >, interval_map<int, int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, split_interval_map<double,int,partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, split_interval_map<int, int,partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, split_interval_map<double,int,total_absorber > >;
- case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, split_interval_map<int, int,total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<icl::list<std::pair<interval_double,int> >, split_interval_map<double,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<icl::list<std::pair<interval_int, int> >, split_interval_map<int, int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<icl::list<std::pair<interval_double,int> >, split_interval_map<double,int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<icl::list<std::pair<interval_int, int> >, split_interval_map<int, int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case split_interval_map
@@ -142,6 +142,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_MAP_COPY_CONFORMITY_DRIVER_HPP_JOFA_091006
Modified: sandbox/itl/boost/validate/driver/map_order_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/map_order_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/map_order_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/validater/itl_order_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class map_order_driver : public itl_driver
@@ -103,18 +103,18 @@
switch(domainChoice) {
case DomainType::Int:
switch(codomainChoice) {
- case CodomainType::Nat: return new itl_order_validater<itl::map<int,nat,total_enricher> >;
- case CodomainType::Int: return new itl_order_validater<itl::map<int,int,partial_absorber> >;
- case CodomainType::set_int: return new itl_order_validater<itl::map<int,std::set<int>,partial_enricher> >;
+ case CodomainType::Nat: return new itl_order_validater<icl::map<int,nat,total_enricher> >;
+ case CodomainType::Int: return new itl_order_validater<icl::map<int,int,partial_absorber> >;
+ case CodomainType::set_int: return new itl_order_validater<icl::map<int,std::set<int>,partial_enricher> >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: codomainChoice:\n"),
codomainChoice, _codomainChoice);
}//switch codomain
case DomainType::Double:
switch(codomainChoice) {
- case CodomainType::Nat: return new itl_order_validater<itl::map<double,nat,partial_enricher> >;
- case CodomainType::Int: return new itl_order_validater<itl::map<double,int,total_absorber> >;
- case CodomainType::set_int: return new itl_order_validater<itl::map<double,std::set<int>,partial_absorber> >;
+ case CodomainType::Nat: return new itl_order_validater<icl::map<double,nat,partial_enricher> >;
+ case CodomainType::Int: return new itl_order_validater<icl::map<double,int,total_absorber> >;
+ case CodomainType::set_int: return new itl_order_validater<icl::map<double,std::set<int>,partial_absorber> >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: codomainChoice:\n"),
codomainChoice, _codomainChoice);
}//switch codomain
@@ -179,5 +179,5 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/set_copy_conformity_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class set_copy_conformity_driver : public itl_driver
@@ -100,10 +100,10 @@
switch(rootChoice)
{
//-----------------------------------------------------------------
- case RootType::itl_set: return new function_equality_validater<itl::list<int>, itl::set<int> >;
- case RootType::interval_set: return new function_equality_validater<itl::list<ITL_INTERVAL_DEFAULT<int> >, interval_set<int> >;
- case RootType::separate_interval_set: return new function_equality_validater<itl::list<ITL_INTERVAL_DEFAULT<int> >, separate_interval_set<int> >;
- case RootType::split_interval_set: return new function_equality_validater<itl::list<ITL_INTERVAL_DEFAULT<int> >, split_interval_set<int> >;
+ case RootType::itl_set: return new function_equality_validater<icl::list<int>, icl::set<int> >;
+ case RootType::interval_set: return new function_equality_validater<icl::list<ITL_INTERVAL_DEFAULT<int> >, interval_set<int> >;
+ case RootType::separate_interval_set: return new function_equality_validater<icl::list<ITL_INTERVAL_DEFAULT<int> >, separate_interval_set<int> >;
+ case RootType::split_interval_set: return new function_equality_validater<icl::list<ITL_INTERVAL_DEFAULT<int> >, split_interval_set<int> >;
//-----------------------------------------------------------------
default: return choiceError(ITL_LOCATION("rootChoice:\n"), rootChoice, _rootChoice);
} //switch()
@@ -113,6 +113,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SET_COPY_CONFORMITY_DRIVER_HPP_JOFA_091013
Modified: sandbox/itl/boost/validate/driver/set_order_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/set_order_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/set_order_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/validater/itl_order_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class set_order_driver : public itl_driver
@@ -138,5 +138,5 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class signed_quantifier_driver : public itl_driver
@@ -104,10 +104,10 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<int, int, partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<int, double, partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double, int, total_absorber > >;
- case IdentityHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double, double, total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new signed_quantifier_validater<icl::map<int, int, partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new signed_quantifier_validater<icl::map<int, double, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new signed_quantifier_validater<icl::map<double, int, total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new signed_quantifier_validater<icl::map<double, double, total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case itl_map
@@ -141,6 +141,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SIGNED_QUANTIFIER_DRIVER_HPP_JOFA_091013
Modified: sandbox/itl/boost/validate/driver/sorted_associative_bitset_back_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_bitset_back_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_bitset_back_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class sorted_associative_bitset_back_driver : public itl_driver
@@ -51,19 +51,19 @@
switch(freeChoice)
{
case FreeChoice::_1:
- return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned char> >, itl::list<int> >;
+ return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned char> >, icl::list<int> >;
case FreeChoice::_2:
- return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned short> >, itl::list<int> >;
+ return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned short> >, icl::list<int> >;
case FreeChoice::_3:
- return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned long> >, itl::list<int> >;
+ return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned long> >, icl::list<int> >;
case FreeChoice::_4:
- return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned long long> >, itl::list<int> >;
+ return new sorted_associative_back_validater< interval_bitset<int, bits<unsigned long long> >, icl::list<int> >;
default: return choiceError(ITL_LOCATION("freeChoice:\n"), freeChoice, _freeChoice);
} //switch()
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SORTED_ASSOCIATIVE_BITSET_BACK_DRIVER_HPP_JOFA_091202
Modified: sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class sorted_associative_bitset_driver : public itl_driver
@@ -51,19 +51,19 @@
switch(freeChoice)
{
case FreeChoice::_1:
- return new sorted_associative_validater< interval_bitset<int, bits<unsigned char> >, itl::list<int> >;
+ return new sorted_associative_validater< interval_bitset<int, bits<unsigned char> >, icl::list<int> >;
case FreeChoice::_2:
- return new sorted_associative_validater< interval_bitset<int, bits<unsigned short> >, itl::list<int> >;
+ return new sorted_associative_validater< interval_bitset<int, bits<unsigned short> >, icl::list<int> >;
case FreeChoice::_3:
- return new sorted_associative_validater< interval_bitset<int, bits<unsigned long> >, itl::list<int> >;
+ return new sorted_associative_validater< interval_bitset<int, bits<unsigned long> >, icl::list<int> >;
case FreeChoice::_4:
- return new sorted_associative_validater< interval_bitset<int, bits<unsigned long long> >, itl::list<int> >;
+ return new sorted_associative_validater< interval_bitset<int, bits<unsigned long long> >, icl::list<int> >;
default: return choiceError(ITL_LOCATION("freeChoice:\n"), freeChoice, _freeChoice);
} //switch()
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SORTED_ASSOCIATIVE_BITSET_DRIVER_HPP_JOFA_091126
Modified: sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_map_back_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class sorted_associative_map_back_driver : public itl_driver
@@ -103,20 +103,20 @@
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new sorted_associative_back_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::partial_enricher: return new sorted_associative_back_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_absorber: return new sorted_associative_back_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_enricher: return new sorted_associative_back_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_back_validater<interval_map<int,int,partial_absorber>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_back_validater<interval_map<int,int,partial_enricher>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_back_validater<interval_map<int,int,total_absorber >, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_back_validater<interval_map<int,int,total_enricher >, icl::list<std::pair<int,int> > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::partial_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,partial_absorber>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,partial_enricher>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_back_validater<split_interval_map<int,int,total_absorber >, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_back_validater<split_interval_map<int,int,total_enricher >, icl::list<std::pair<int,int> > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case split_interval_map
@@ -129,6 +129,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SORTED_ASSOCIATIVE_MAP_BACK_DRIVER_HPP_JOFA_091202
Modified: sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class sorted_associative_map_driver : public itl_driver
@@ -103,20 +103,20 @@
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new sorted_associative_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::partial_enricher: return new sorted_associative_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_absorber: return new sorted_associative_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_enricher: return new sorted_associative_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_validater<interval_map<int,int,partial_absorber>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_validater<interval_map<int,int,partial_enricher>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_validater<interval_map<int,int,total_absorber >, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_validater<interval_map<int,int,total_enricher >, icl::list<std::pair<int,int> > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new sorted_associative_validater<split_interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::partial_enricher: return new sorted_associative_validater<split_interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_absorber: return new sorted_associative_validater<split_interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
- case IdentityHandlerType::total_enricher: return new sorted_associative_validater<split_interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_absorber: return new sorted_associative_validater<split_interval_map<int,int,partial_absorber>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::partial_enricher: return new sorted_associative_validater<split_interval_map<int,int,partial_enricher>, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_absorber: return new sorted_associative_validater<split_interval_map<int,int,total_absorber >, icl::list<std::pair<int,int> > >;
+ case IdentityHandlerType::total_enricher: return new sorted_associative_validater<split_interval_map<int,int,total_enricher >, icl::list<std::pair<int,int> > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case split_interval_map
@@ -129,6 +129,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SORTED_ASSOCIATIVE_MAP_DRIVER_HPP_JOFA_091126
Modified: sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_set_back_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class sorted_associative_set_back_driver : public itl_driver
@@ -99,15 +99,15 @@
switch(rootChoice)
{
- case RootType:: interval_set: return new sorted_associative_back_validater< interval_set<int>, itl::list<int> >;
- case RootType::separate_interval_set: return new sorted_associative_back_validater<separate_interval_set<int>, itl::list<int> >;
- case RootType:: split_interval_set: return new sorted_associative_back_validater< split_interval_set<int>, itl::list<int> >;
+ case RootType:: interval_set: return new sorted_associative_back_validater< interval_set<int>, icl::list<int> >;
+ case RootType::separate_interval_set: return new sorted_associative_back_validater<separate_interval_set<int>, icl::list<int> >;
+ case RootType:: split_interval_set: return new sorted_associative_back_validater< split_interval_set<int>, icl::list<int> >;
default: return choiceError(ITL_LOCATION("rootChoice:\n"), rootChoice, _rootChoice);
} //switch()
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SORTED_ASSOCIATIVE_SET_BACK_DRIVER_HPP_JOFA_091202
Modified: sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_set_driver.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class sorted_associative_set_driver : public itl_driver
@@ -100,9 +100,9 @@
switch(rootChoice)
{
- case RootType:: interval_set: return new sorted_associative_validater< interval_set<int>, itl::list<int> >;
- case RootType::separate_interval_set: return new sorted_associative_validater<separate_interval_set<int>, itl::list<int> >;
- case RootType:: split_interval_set: return new sorted_associative_validater< split_interval_set<int>, itl::list<int> >;
+ case RootType:: interval_set: return new sorted_associative_validater< interval_set<int>, icl::list<int> >;
+ case RootType::separate_interval_set: return new sorted_associative_validater<separate_interval_set<int>, icl::list<int> >;
+ case RootType:: split_interval_set: return new sorted_associative_validater< split_interval_set<int>, icl::list<int> >;
default: return choiceError(ITL_LOCATION("rootChoice:\n"), rootChoice, _rootChoice);
} //switch()
@@ -110,6 +110,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_DRIVER_SORTED_ASSOCIATIVE_SET_DRIVER_HPP_JOFA_091126
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/validate/driver/itl_driver.hpp>
#include <boost/validate/utility.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class unsigned_quantifier_driver : public itl_driver
@@ -103,10 +103,10 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<double,double,partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<double,nat, partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new unsigned_quantifier_validater<itl::map<int, double,total_absorber > >;
- case IdentityHandlerType::total_enricher: return new unsigned_quantifier_validater<itl::map<int, nat, total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new unsigned_quantifier_validater<icl::map<double,double,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new unsigned_quantifier_validater<icl::map<double,nat, partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new unsigned_quantifier_validater<icl::map<int, double,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new unsigned_quantifier_validater<icl::map<int, nat, total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case itl_map
@@ -140,5 +140,5 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/interval_type_default.hpp>
#include <boost/itl/interval.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class GentorProfile
@@ -30,35 +30,35 @@
void set_polygon_profile(int max_polygon_set_size, int max_polygon_size, int min_coord, int max_coord);
void set_range_int(int lwb, int upb)
- { _range_int = itl::interval<int>::right_open(lwb, upb); }
+ { _range_int = icl::interval<int>::right_open(lwb, upb); }
void set_range_nat(cnat lwb, cnat upb)
- { _range_nat = itl::interval<cnat>::right_open(lwb, upb); }
+ { _range_nat = icl::interval<cnat>::right_open(lwb, upb); }
void set_range_double(double lwb, double upb)
- { _range_double = itl::interval<double>::right_open(lwb, upb); }
+ { _range_double = icl::interval<double>::right_open(lwb, upb); }
void set_range_ContainerSize(int lwb, int upb)
- { _range_ContainerSize = itl::interval<int>::right_open(lwb, upb); }
+ { _range_ContainerSize = icl::interval<int>::right_open(lwb, upb); }
void set_range_interval_int(int lwb, int upb)
- { _range_interval_int = itl::interval<int>::right_open(lwb, upb); }
+ { _range_interval_int = icl::interval<int>::right_open(lwb, upb); }
void set_range_interval_double(double lwb, double upb)
- { _range_interval_double = itl::interval<double>::right_open(lwb, upb); }
+ { _range_interval_double = icl::interval<double>::right_open(lwb, upb); }
void set_maxIntervalLength(int val)
{ _maxIntervalLength = val; }
void set_range_codomain_ContainerSize(int lwb, int upb)
- { _range_codomain_ContainerSize = itl::interval<int>::right_open(lwb, upb); }
+ { _range_codomain_ContainerSize = icl::interval<int>::right_open(lwb, upb); }
void set_repeat_count(int repeat) { _repeat_count = repeat; }
void set_trials_count(int trials) { _trials_count = trials; }
void set_trials_count_release(int trials) { _trials_count_release = trials; }
void set_laws_per_cycle(int count){ _laws_per_cycle = count; }
void set_debug_slowdown(double factor){ _debug_slowdown = factor; }
- itl::interval<int>::type range_int() { return _range_int; }
- itl::interval<cnat>::type range_nat() { return _range_nat; }
- itl::interval<double>::type range_double() { return _range_double; }
- itl::interval<int>::type range_ContainerSize() { return _range_ContainerSize; }
- itl::interval<int>::type range_interval_int() { return _range_interval_int; }
- itl::interval<double>::type range_interval_double() { return _range_interval_double; }
+ icl::interval<int>::type range_int() { return _range_int; }
+ icl::interval<cnat>::type range_nat() { return _range_nat; }
+ icl::interval<double>::type range_double() { return _range_double; }
+ icl::interval<int>::type range_ContainerSize() { return _range_ContainerSize; }
+ icl::interval<int>::type range_interval_int() { return _range_interval_int; }
+ icl::interval<double>::type range_interval_double() { return _range_interval_double; }
int maxIntervalLength() { return _maxIntervalLength; }
- itl::interval<int>::type range_codomain_ContainerSize()
+ icl::interval<int>::type range_codomain_ContainerSize()
{ return _range_codomain_ContainerSize; }
int repeat_count() { return _repeat_count; }
int trials_count() { return _trials_count; }
@@ -75,16 +75,16 @@
void report_profile();
private:
- itl::interval<int>::type _range_int;
- itl::interval<cnat>::type _range_nat;
- itl::interval<double>::type _range_double;
- itl::interval<int>::type _range_ContainerSize;
+ icl::interval<int>::type _range_int;
+ icl::interval<cnat>::type _range_nat;
+ icl::interval<double>::type _range_double;
+ icl::interval<int>::type _range_ContainerSize;
- itl::interval<int>::type _range_interval_int;
- itl::interval<double>::type _range_interval_double;
+ icl::interval<int>::type _range_interval_int;
+ icl::interval<double>::type _range_interval_double;
int _maxIntervalLength;
- itl::interval<int>::type _range_codomain_ContainerSize;
+ icl::interval<int>::type _range_codomain_ContainerSize;
int _repeat_count;
int _trials_count;
int _trials_count_release;
@@ -122,14 +122,14 @@
void set_trials_count(int trials) { m_profile.set_trials_count(trials); }
void set_laws_per_cycle(int count) { m_profile.set_laws_per_cycle(count); }
- itl::interval<int>::type range_int() { return m_profile.range_int(); }
- itl::interval<cnat>::type range_nat() { return m_profile.range_nat(); }
- itl::interval<double>::type range_double() { return m_profile.range_double(); }
- itl::interval<int>::type range_ContainerSize(){ return m_profile.range_ContainerSize(); }
- itl::interval<int>::type range_interval_int() { return m_profile.range_interval_int(); }
- itl::interval<double>::type range_interval_double() { return m_profile.range_interval_double();}
+ icl::interval<int>::type range_int() { return m_profile.range_int(); }
+ icl::interval<cnat>::type range_nat() { return m_profile.range_nat(); }
+ icl::interval<double>::type range_double() { return m_profile.range_double(); }
+ icl::interval<int>::type range_ContainerSize(){ return m_profile.range_ContainerSize(); }
+ icl::interval<int>::type range_interval_int() { return m_profile.range_interval_int(); }
+ icl::interval<double>::type range_interval_double() { return m_profile.range_interval_double();}
int maxIntervalLength() { return m_profile.maxIntervalLength(); }
- itl::interval<int>::type range_codomain_ContainerSize(){ return m_profile.range_codomain_ContainerSize(); }
+ icl::interval<int>::type range_codomain_ContainerSize(){ return m_profile.range_codomain_ContainerSize(); }
int repeat_count() { return m_profile.repeat_count(); }
int trials_count() { return m_profile.trials_count(); }
int laws_per_cycle() { return m_profile.laws_per_cycle(); }
@@ -154,38 +154,38 @@
template<typename NumberT>
struct GentorProfileSgl_numeric_range
{
- static typename itl::interval<NumberT>::type get();
+ static typename icl::interval<NumberT>::type get();
};
template<>
struct GentorProfileSgl_numeric_range<int>
{
- static itl::interval<int>::type get()
+ static icl::interval<int>::type get()
{ return GentorProfileSgl::it()->range_int(); }
};
template<>
struct GentorProfileSgl_numeric_range<unsigned int>
{
- static itl::interval<unsigned int>::type get()
+ static icl::interval<unsigned int>::type get()
{
- itl::interval<cnat>::type inter_val = GentorProfileSgl::it()->range_nat();
- return itl::interval<unsigned int>::right_open(inter_val.lower(), inter_val.upper());
+ icl::interval<cnat>::type inter_val = GentorProfileSgl::it()->range_nat();
+ return icl::interval<unsigned int>::right_open(inter_val.lower(), inter_val.upper());
}
};
template<>
struct GentorProfileSgl_numeric_range<cnat>
{
- static itl::interval<cnat>::type get()
+ static icl::interval<cnat>::type get()
{ return GentorProfileSgl::it()->range_nat(); }
};
template<>
struct GentorProfileSgl_numeric_range<double>
{
- static itl::interval<double>::type get()
+ static icl::interval<double>::type get()
{ return GentorProfileSgl::it()->range_double(); }
};
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
@@ -39,7 +39,7 @@
#include <boost/validate/gentor/gentorprofile.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// -------------------------------------------------------------------------
@@ -50,8 +50,8 @@
// -------------------------------------------------------------------------
template <class NaturalT>
- class RandomGentor<itl::bits<NaturalT> > :
- public bits_gentor<itl::bits<NaturalT> > {};
+ class RandomGentor<icl::bits<NaturalT> > :
+ public bits_gentor<icl::bits<NaturalT> > {};
// -------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare>
@@ -69,18 +69,18 @@
template <class DomainT>
- class RandomGentor<itl::list<DomainT> > :
- public SeqGentorT<itl::list<DomainT> > {};
+ class RandomGentor<icl::list<DomainT> > :
+ public SeqGentorT<icl::list<DomainT> > {};
#ifdef LAW_BASED_TEST_BOOST_POLYGON
// -------------------------------------------------------------------------
template <class DomainT>
- class RandomGentor<itl::point<DomainT> > :
+ class RandomGentor<icl::point<DomainT> > :
public point_gentor<DomainT> {};
template <class PointT>
- class RandomGentor<itl::list<itl::list<PointT> > > :
- public polygon_set_gentor<itl::list<itl::list<PointT> > > {};
+ class RandomGentor<icl::list<icl::list<PointT> > > :
+ public polygon_set_gentor<icl::list<icl::list<PointT> > > {};
#endif //LAW_BASED_TEST_BOOST_POLYGON
// ----- lists -------------------------------------------------------------
@@ -93,76 +93,76 @@
public map_segment_gentor<DomainT,CodomainT,continuous_interval<DomainT,Compare> > {};
template <class DomainT, class CodomainT, ITL_COMPARE Compare>
- class RandomGentor<itl::list<std::pair<discrete_interval<DomainT,Compare>, CodomainT> > > :
- public SeqGentorT<itl::list<std::pair<discrete_interval<DomainT,Compare>, CodomainT> > > {};
+ class RandomGentor<icl::list<std::pair<discrete_interval<DomainT,Compare>, CodomainT> > > :
+ public SeqGentorT<icl::list<std::pair<discrete_interval<DomainT,Compare>, CodomainT> > > {};
template <class DomainT, class CodomainT, ITL_COMPARE Compare>
- class RandomGentor<itl::list<std::pair<continuous_interval<DomainT,Compare>, CodomainT> > > :
- public SeqGentorT<itl::list<std::pair<continuous_interval<DomainT,Compare>, CodomainT> > > {};
+ class RandomGentor<icl::list<std::pair<continuous_interval<DomainT,Compare>, CodomainT> > > :
+ public SeqGentorT<icl::list<std::pair<continuous_interval<DomainT,Compare>, CodomainT> > > {};
template <class DomainT, class CodomainT>
- class RandomGentor<itl::list<std::pair<DomainT,CodomainT> > > :
- public SeqGentorT<itl::list<std::pair<DomainT,CodomainT> > > {};
+ class RandomGentor<icl::list<std::pair<DomainT,CodomainT> > > :
+ public SeqGentorT<icl::list<std::pair<DomainT,CodomainT> > > {};
template <class DomainT, ITL_COMPARE Compare>
- class RandomGentor<itl::list<discrete_interval<DomainT,Compare> > > :
- public SeqGentorT<itl::list<discrete_interval<DomainT,Compare> > > {};
+ class RandomGentor<icl::list<discrete_interval<DomainT,Compare> > > :
+ public SeqGentorT<icl::list<discrete_interval<DomainT,Compare> > > {};
template <class DomainT, ITL_COMPARE Compare>
- class RandomGentor<itl::list<continuous_interval<DomainT,Compare> > > :
- public SeqGentorT<itl::list<continuous_interval<DomainT,Compare> > > {};
+ class RandomGentor<icl::list<continuous_interval<DomainT,Compare> > > :
+ public SeqGentorT<icl::list<continuous_interval<DomainT,Compare> > > {};
// ----- sets --------------------------------------------------------------
template <class DomainT>
- class RandomGentor<itl::set<DomainT> > :
- public SetGentorT<itl::set<DomainT> > {};
+ class RandomGentor<icl::set<DomainT> > :
+ public SetGentorT<icl::set<DomainT> > {};
template <class DomainT>
class RandomGentor<std::set<DomainT> > :
public SetGentorT<std::set<DomainT> > {};
template <class DomainT>
- class RandomGentor<itl::interval_set<DomainT> > :
- public SetGentorT<itl::interval_set<DomainT> > {};
+ class RandomGentor<icl::interval_set<DomainT> > :
+ public SetGentorT<icl::interval_set<DomainT> > {};
template <class DomainT>
- class RandomGentor<itl::separate_interval_set<DomainT> > :
- public SetGentorT<itl::separate_interval_set<DomainT> > {};
+ class RandomGentor<icl::separate_interval_set<DomainT> > :
+ public SetGentorT<icl::separate_interval_set<DomainT> > {};
template <class DomainT>
- class RandomGentor<itl::split_interval_set<DomainT> > :
- public SetGentorT<itl::split_interval_set<DomainT> > {};
+ class RandomGentor<icl::split_interval_set<DomainT> > :
+ public SetGentorT<icl::split_interval_set<DomainT> > {};
// ----- tree --------------------------------------------------------------
#ifdef USE_ITL_TREE
template <class DomainT>
- class RandomGentor<itl::tree<DomainT> > :
- public SetGentorT<itl::tree<DomainT> > {};
+ class RandomGentor<icl::tree<DomainT> > :
+ public SetGentorT<icl::tree<DomainT> > {};
#endif
// ----- maps --------------------------------------------------------------
template <class DomainT, class Neutronizer>
- class RandomGentor<itl::map<DomainT,itl::set<int>,Neutronizer> > :
- public MapGentorT<itl::map<DomainT,itl::set<int>,Neutronizer> > {};
+ class RandomGentor<icl::map<DomainT,icl::set<int>,Neutronizer> > :
+ public MapGentorT<icl::map<DomainT,icl::set<int>,Neutronizer> > {};
template <class DomainT, class Neutronizer>
- class RandomGentor<itl::map<DomainT,std::set<int>,Neutronizer> > :
- public MapGentorT<itl::map<DomainT,std::set<int>,Neutronizer> > {};
+ class RandomGentor<icl::map<DomainT,std::set<int>,Neutronizer> > :
+ public MapGentorT<icl::map<DomainT,std::set<int>,Neutronizer> > {};
template <class DomainT, class BitsT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
- class RandomGentor<itl::map<DomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
- public MapGentorT<itl::map<DomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
+ class RandomGentor<icl::map<DomainT,icl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
+ public MapGentorT<icl::map<DomainT,icl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
template <class DomainT, class CodomainT, class Neutronizer>
- class RandomGentor<itl::map<DomainT,CodomainT,Neutronizer> > :
- public MapGentorT<itl::map<DomainT,CodomainT,Neutronizer> > {};
+ class RandomGentor<icl::map<DomainT,CodomainT,Neutronizer> > :
+ public MapGentorT<icl::map<DomainT,CodomainT,Neutronizer> > {};
// ----- interval_map<D,C,N> -----------------------------------------------
template <class DomainT, class Neutronizer>
- class RandomGentor<interval_map<DomainT,itl::set<int>,Neutronizer> > :
- public MapGentorT<interval_map<DomainT,itl::set<int>,Neutronizer> > {};
+ class RandomGentor<interval_map<DomainT,icl::set<int>,Neutronizer> > :
+ public MapGentorT<interval_map<DomainT,icl::set<int>,Neutronizer> > {};
template <class DomainT, class Neutronizer>
class RandomGentor<interval_map<DomainT,std::set<int>,Neutronizer> > :
@@ -174,8 +174,8 @@
// ----- split_interval_map<D,C,N> ----------------------------------------
template <class DomainT, class Neutronizer>
- class RandomGentor<split_interval_map<DomainT,itl::set<int>,Neutronizer> > :
- public MapGentorT<split_interval_map<DomainT,itl::set<int>,Neutronizer> > {};
+ class RandomGentor<split_interval_map<DomainT,icl::set<int>,Neutronizer> > :
+ public MapGentorT<split_interval_map<DomainT,icl::set<int>,Neutronizer> > {};
template <class DomainT, class Neutronizer>
class RandomGentor<split_interval_map<DomainT,std::set<int>,Neutronizer> > :
@@ -189,18 +189,18 @@
// ------------------------------------------------------------------------
template <class NumericDomainT, class BitsT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
- class RandomGentor<split_interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
- public MapGentorT<split_interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
+ class RandomGentor<split_interval_map<NumericDomainT,icl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
+ public MapGentorT<split_interval_map<NumericDomainT,icl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
template <class NumericDomainT, class BitsT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
- class RandomGentor<interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
- public MapGentorT<interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
+ class RandomGentor<interval_map<NumericDomainT,icl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
+ public MapGentorT<interval_map<NumericDomainT,icl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
// ------------------------------------------------------------------------
template <class NumericDomainT, class BitsT>
- class RandomGentor<interval_bitset<NumericDomainT,itl::bits<BitsT> > > :
- public MapGentorT<interval_bitset<NumericDomainT,itl::bits<BitsT> > > {};
+ class RandomGentor<interval_bitset<NumericDomainT,icl::bits<BitsT> > > :
+ public MapGentorT<interval_bitset<NumericDomainT,icl::bits<BitsT> > > {};
// ------------------------------------------------------------------------
//NOTE: All trials to reduce code replication for RandomGentor
@@ -271,12 +271,12 @@
};
template <class BitsT>
- struct Calibrater<itl::bits<BitsT>, RandomGentor>
+ struct Calibrater<icl::bits<BitsT>, RandomGentor>
{
- static void apply(RandomGentor<itl::bits<BitsT> >& gentor)
+ static void apply(RandomGentor<icl::bits<BitsT> >& gentor)
{
// Set the range within which the sizes of the generated object varies.
- gentor.set_range(itl::interval<BitsT>::right_open(0, sizeof(BitsT)));
+ gentor.set_range(icl::interval<BitsT>::right_open(0, sizeof(BitsT)));
}
};
@@ -297,9 +297,9 @@
// boost::polygon
//--------------------------------------------------------------------------
template <>
- struct Calibrater<itl::point<int>, RandomGentor>
+ struct Calibrater<icl::point<int>, RandomGentor>
{
- static void apply(RandomGentor<itl::point<int> >& gentor)
+ static void apply(RandomGentor<icl::point<int> >& gentor)
{
// Set the range within which the sizes of the generated object varies.
gentor.setRange(GentorProfileSgl::it()->range_int());
@@ -307,9 +307,9 @@
};
template <>
- struct Calibrater<itl::list<point<int> >, RandomGentor>
+ struct Calibrater<icl::list<point<int> >, RandomGentor>
{
- static void apply(RandomGentor<itl::list<point<int> > >& gentor)
+ static void apply(RandomGentor<icl::list<point<int> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_codomain_ContainerSize());
point_gentor<int>* pointGentor = new point_gentor<int>;
@@ -320,9 +320,9 @@
};
template <>
- struct Calibrater<itl::list<list<point<int> > >, RandomGentor>
+ struct Calibrater<icl::list<list<point<int> > >, RandomGentor>
{
- static void apply(RandomGentor<itl::list<list<point<int> > > >& gentor)
+ static void apply(RandomGentor<icl::list<list<point<int> > > >& gentor)
{
point_gentor<int>* pointGentor = new point_gentor<int>;
pointGentor->setRange(GentorProfileSgl::it()->range_int());
@@ -374,9 +374,9 @@
};
template <ITL_INTERVAL(ITL_COMPARE) Interval>
- struct Calibrater<itl::list<std::pair<Interval, int> >, RandomGentor>
+ struct Calibrater<icl::list<std::pair<Interval, int> >, RandomGentor>
{
- static void apply(RandomGentor< itl::list<std::pair<Interval, int> > >& gentor)
+ static void apply(RandomGentor< icl::list<std::pair<Interval, int> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
map_segment_gentor<double,int,Interval >* segment_gentor
@@ -392,9 +392,9 @@
};
template <class NumericT, ITL_COMPARE Compare>
- struct Calibrater<itl::list< continuous_interval<NumericT,Compare> >, RandomGentor>
+ struct Calibrater<icl::list< continuous_interval<NumericT,Compare> >, RandomGentor>
{
- static void apply(RandomGentor< itl::list< continuous_interval<NumericT,Compare> > >& gentor)
+ static void apply(RandomGentor< icl::list< continuous_interval<NumericT,Compare> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
ItvGentorT<NumericT, continuous_interval<NumericT,Compare> >* itvGentor
@@ -406,9 +406,9 @@
};
template <class NumericT, ITL_COMPARE Compare>
- struct Calibrater<itl::list< discrete_interval<NumericT,Compare> >, RandomGentor>
+ struct Calibrater<icl::list< discrete_interval<NumericT,Compare> >, RandomGentor>
{
- static void apply(RandomGentor< itl::list< discrete_interval<NumericT,Compare> > >& gentor)
+ static void apply(RandomGentor< icl::list< discrete_interval<NumericT,Compare> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
ItvGentorT<NumericT, discrete_interval<NumericT,Compare> >* itvGentor
@@ -420,9 +420,9 @@
};
template <class NumericT, ITL_COMPARE Compare>
- struct Calibrater<itl::list< right_open_interval<NumericT,Compare> >, RandomGentor>
+ struct Calibrater<icl::list< right_open_interval<NumericT,Compare> >, RandomGentor>
{
- static void apply(RandomGentor< itl::list< right_open_interval<NumericT,Compare> > >& gentor)
+ static void apply(RandomGentor< icl::list< right_open_interval<NumericT,Compare> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
ItvGentorT<NumericT, right_open_interval<NumericT,Compare> >* itvGentor
@@ -434,9 +434,9 @@
};
template <class NumericT>
- struct Calibrater<itl::list<NumericT>, RandomGentor>
+ struct Calibrater<icl::list<NumericT>, RandomGentor>
{
- static void apply(RandomGentor< itl::list<NumericT> >& gentor)
+ static void apply(RandomGentor< icl::list<NumericT> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
NumberGentorT<NumericT>* domainGentor = new NumberGentorT<NumericT>;
@@ -446,9 +446,9 @@
};
template <>
- struct Calibrater<itl::list<std::pair<int, int> >, RandomGentor>
+ struct Calibrater<icl::list<std::pair<int, int> >, RandomGentor>
{
- static void apply(RandomGentor< itl::list< std::pair<int, int> > >& gentor)
+ static void apply(RandomGentor< icl::list< std::pair<int, int> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
std_pair_gentor<int,int>* pair_gentor = new std_pair_gentor<int,int>;
@@ -463,9 +463,9 @@
};
template <ITL_COMPARE Compare>
- struct Calibrater<itl::list<std::pair<discrete_interval<int,Compare>, int> >, RandomGentor>
+ struct Calibrater<icl::list<std::pair<discrete_interval<int,Compare>, int> >, RandomGentor>
{
- static void apply(RandomGentor< itl::list<std::pair<discrete_interval<int,Compare>, int> > >& gentor)
+ static void apply(RandomGentor< icl::list<std::pair<discrete_interval<int,Compare>, int> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
map_segment_gentor<int,int,discrete_interval<int,Compare> >* segment_gentor
@@ -484,9 +484,9 @@
// sets
//--------------------------------------------------------------------------
template <>
- struct Calibrater<itl::set<int>, RandomGentor>
+ struct Calibrater<icl::set<int>, RandomGentor>
{
- static void apply(RandomGentor<itl::set<int> >& gentor)
+ static void apply(RandomGentor<icl::set<int> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
NumberGentorT<int>* intGentor = new NumberGentorT<int>;
@@ -496,9 +496,9 @@
};
template <>
- struct Calibrater<itl::set<double>, RandomGentor>
+ struct Calibrater<icl::set<double>, RandomGentor>
{
- static void apply(RandomGentor<itl::set<double> >& gentor)
+ static void apply(RandomGentor<icl::set<double> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
NumberGentorT<double>* elemGentor = new NumberGentorT<double>;
@@ -533,7 +533,7 @@
};
//----------------------------------------------------------------------------
- // itl::{,separate,split}_interval_set<NumericDomainT>
+ // icl::{,separate,split}_interval_set<NumericDomainT>
//----------------------------------------------------------------------------
template <class NumericDomainT, ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
struct Calibrater<interval_set<NumericDomainT,Compare,Interval>, RandomGentor>
@@ -578,18 +578,18 @@
};
//--------------------------------------------------------------------------
- // itl::tree
+ // icl::tree
//--------------------------------------------------------------------------
#ifdef USE_ITL_TREE
template <>
- struct Calibrater<itl::tree<int>, RandomGentor>
+ struct Calibrater<icl::tree<int>, RandomGentor>
{
- static void apply(RandomGentor<itl::tree<int> >& gentor)
+ static void apply(RandomGentor<icl::tree<int> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
ItvGentorT<int, discrete_interval<int,Compare> >* itvGentor
= new ItvGentorT<int, discrete_interval<int,Compare> >;
- typename itl::interval<int>::type valRange = GentorProfileSgl::it()->range_interval_int();
+ typename icl::interval<int>::type valRange = GentorProfileSgl::it()->range_interval_int();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
gentor.setDomainGentor(itvGentor);
@@ -598,12 +598,12 @@
#endif
//----------------------------------------------------------------------------
- // itl::map<DomainT,CodomainT,Neutronizer>
+ // icl::map<DomainT,CodomainT,Neutronizer>
//----------------------------------------------------------------------------
template <typename NumericDomainT, class Neutronizer>
- struct Calibrater<itl::map<NumericDomainT,itl::set<int>,Neutronizer>, RandomGentor>
+ struct Calibrater<icl::map<NumericDomainT,icl::set<int>,Neutronizer>, RandomGentor>
{
- static void apply(RandomGentor<itl::map<NumericDomainT,itl::set<int>,Neutronizer> >& gentor)
+ static void apply(RandomGentor<icl::map<NumericDomainT,icl::set<int>,Neutronizer> >& gentor)
{
// Set the range within which the sizes of the generated object varies.
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -613,7 +613,7 @@
NumberGentorT<NumericDomainT>* domainGentor = new NumberGentorT<NumericDomainT>;
domainGentor->setRange(GentorProfileSgl_numeric_range<NumericDomainT>::get());
- SetGentorT<itl::set<int> >* codomainGentor = new SetGentorT<itl::set<int> >;
+ SetGentorT<icl::set<int> >* codomainGentor = new SetGentorT<icl::set<int> >;
NumberGentorT<int>* elementGentor = new NumberGentorT<int>;
elementGentor->setRange(GentorProfileSgl_numeric_range<int>::get());
@@ -626,9 +626,9 @@
};
template <typename NumericDomainT, class Neutronizer>
- struct Calibrater<itl::map<NumericDomainT,std::set<int>,Neutronizer>, RandomGentor>
+ struct Calibrater<icl::map<NumericDomainT,std::set<int>,Neutronizer>, RandomGentor>
{
- static void apply(RandomGentor<itl::map<NumericDomainT,std::set<int>,Neutronizer> >& gentor)
+ static void apply(RandomGentor<icl::map<NumericDomainT,std::set<int>,Neutronizer> >& gentor)
{
// Set the range within which the sizes of the generated object varies.
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -651,9 +651,9 @@
};
template <typename NumericDomainT, typename NumericCodomainT, class Neutronizer>
- struct Calibrater<itl::map<NumericDomainT,NumericCodomainT,Neutronizer>, RandomGentor>
+ struct Calibrater<icl::map<NumericDomainT,NumericCodomainT,Neutronizer>, RandomGentor>
{
- static void apply(RandomGentor<itl::map<NumericDomainT,NumericCodomainT,Neutronizer> >& gentor)
+ static void apply(RandomGentor<icl::map<NumericDomainT,NumericCodomainT,Neutronizer> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -670,10 +670,10 @@
template <typename NumericDomainT, typename BitsT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
- struct Calibrater<itl::map<NumericDomainT,itl::bits<BitsT>,Neutronizer,
+ struct Calibrater<icl::map<NumericDomainT,icl::bits<BitsT>,Neutronizer,
Compare,Combine,Section>, RandomGentor>
{
- static void apply(RandomGentor<itl::map<NumericDomainT,itl::bits<BitsT>,Neutronizer,
+ static void apply(RandomGentor<icl::map<NumericDomainT,icl::bits<BitsT>,Neutronizer,
Compare,Combine,Section> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -683,23 +683,23 @@
NumberGentorT<NumericDomainT>* domainGentor = new NumberGentorT<NumericDomainT>;
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
domainGentor->setRange(GentorProfileSgl_numeric_range<NumericDomainT>::get());
- codomainGentor->set_range(itl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(icl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(domainGentor);
gentor.setCodomainGentor(codomainGentor);
}
};
//----------------------------------------------------------------------------
- // itl::interval_map<DomainT,CodomainT,Neutronizer>
+ // icl::interval_map<DomainT,CodomainT,Neutronizer>
//----------------------------------------------------------------------------
template <class NumericDomainT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
ITL_INTERVAL(ITL_COMPARE) Interval>
- struct Calibrater<interval_map<NumericDomainT,itl::set<int>,
+ struct Calibrater<interval_map<NumericDomainT,icl::set<int>,
Neutronizer,Compare,Combine,Section,
Interval >, RandomGentor>
{
- static void apply(RandomGentor<interval_map<NumericDomainT,itl::set<int>,
+ static void apply(RandomGentor<interval_map<NumericDomainT,icl::set<int>,
Neutronizer,Compare,Combine,Section,
Interval > >& gentor)
{
@@ -708,11 +708,11 @@
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
- SetGentorT<itl::set<int> >* codomainGentor = new SetGentorT<itl::set<int> >;
+ SetGentorT<icl::set<int> >* codomainGentor = new SetGentorT<icl::set<int> >;
NumberGentorT<int>* elementGentor = new NumberGentorT<int>;
elementGentor->setRange(GentorProfileSgl::it()->range_int());
@@ -740,7 +740,7 @@
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -774,7 +774,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -787,16 +787,16 @@
};
//----------------------------------------------------------------------------
- // itl::split_interval_map<DomainT,CodomainT,Neutronizer>
+ // icl::split_interval_map<DomainT,CodomainT,Neutronizer>
//----------------------------------------------------------------------------
template <class NumericDomainT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
ITL_INTERVAL(ITL_COMPARE) Interval>
- struct Calibrater<split_interval_map<NumericDomainT,itl::set<int>,
+ struct Calibrater<split_interval_map<NumericDomainT,icl::set<int>,
Neutronizer,Compare,Combine,Section,
Interval >, RandomGentor>
{
- static void apply(RandomGentor<split_interval_map<NumericDomainT,itl::set<int>,
+ static void apply(RandomGentor<split_interval_map<NumericDomainT,icl::set<int>,
Neutronizer,Compare,Combine,Section,
Interval > >& gentor)
{
@@ -806,11 +806,11 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
- SetGentorT<itl::set<int> >* codomainGentor = new SetGentorT<itl::set<int> >;
+ SetGentorT<icl::set<int> >* codomainGentor = new SetGentorT<icl::set<int> >;
NumberGentorT<int>* elementGentor = new NumberGentorT<int>;
elementGentor->setRange(GentorProfileSgl::it()->range_int());
@@ -839,7 +839,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -873,7 +873,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -889,11 +889,11 @@
template <typename NumericDomainT, typename BitsT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
ITL_INTERVAL(ITL_COMPARE) Interval>
- struct Calibrater<interval_map<NumericDomainT,itl::bits<BitsT>,
+ struct Calibrater<interval_map<NumericDomainT,icl::bits<BitsT>,
Neutronizer,Compare,Combine,Section,
Interval >, RandomGentor>
{
- static void apply(RandomGentor<interval_map<NumericDomainT,itl::bits<BitsT>,
+ static void apply(RandomGentor<interval_map<NumericDomainT,icl::bits<BitsT>,
Neutronizer,Compare,Combine,Section,
Interval > >& gentor)
{
@@ -903,12 +903,12 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(itl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(icl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
@@ -919,11 +919,11 @@
template <typename NumericDomainT, typename BitsT, class Neutronizer,
ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section,
ITL_INTERVAL(ITL_COMPARE) Interval>
- struct Calibrater<split_interval_map<NumericDomainT,itl::bits<BitsT>,
+ struct Calibrater<split_interval_map<NumericDomainT,icl::bits<BitsT>,
Neutronizer,Compare,Combine,Section,
Interval >, RandomGentor>
{
- static void apply(RandomGentor<split_interval_map<NumericDomainT,itl::bits<BitsT>,
+ static void apply(RandomGentor<split_interval_map<NumericDomainT,icl::bits<BitsT>,
Neutronizer,Compare,Combine,Section,
Interval > >& gentor)
{
@@ -933,12 +933,12 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(itl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(icl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
@@ -948,10 +948,10 @@
template <typename NumericDomainT, typename BitsT,
ITL_COMPARE Compare, ITL_INTERVAL(ITL_COMPARE) Interval>
- struct Calibrater<interval_bitset<NumericDomainT,itl::bits<BitsT>,
+ struct Calibrater<interval_bitset<NumericDomainT,icl::bits<BitsT>,
Compare, Interval >, RandomGentor>
{
- static void apply(RandomGentor<interval_bitset<NumericDomainT,itl::bits<BitsT>,
+ static void apply(RandomGentor<interval_bitset<NumericDomainT,icl::bits<BitsT>,
Compare, Interval> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -960,12 +960,12 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- typename itl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename icl::interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(itl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(icl::interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
@@ -974,4 +974,4 @@
// ---------------------------------------------------------------------------
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/gentor/rangegentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/rangegentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/rangegentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -36,31 +36,31 @@
#include <boost/itl_xt/gentorit.hpp>
#include <boost/itl_xt/numbergentor.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class Type>
- class RangeGentor: public RandomGentorAT<typename itl::interval<Type>::type >
+ class RangeGentor: public RandomGentorAT<typename icl::interval<Type>::type >
{
public:
- typedef typename itl::interval<Type>::type interval_type;
+ typedef typename icl::interval<Type>::type interval_type;
public:
virtual void some(interval_type& x);
interval_type last()const;
void setLowerBoundRange(int lwb, int upb)
- { setLowerBoundRange(itl::interval<int>::right_open(lwb,upb)); }
+ { setLowerBoundRange(icl::interval<int>::right_open(lwb,upb)); }
- void setLowerBoundRange(const itl::interval<int>::type& range)
+ void setLowerBoundRange(const icl::interval<int>::type& range)
{
//JODO? BOOST_ASSERT(range.is_right_open()||range.is_closed());
_lwbGentor.setRange(range);
}
void setUpperBoundRange(int lwb, int upb)
- { setUpperBoundRange(itl::interval<int>::right_open(lwb,upb)); }
+ { setUpperBoundRange(icl::interval<int>::right_open(lwb,upb)); }
- void setUpperBoundRange(const itl::interval<int>::type& range)
+ void setUpperBoundRange(const icl::interval<int>::type& range)
{
//JODO? BOOST_ASSERT(range.is_right_open()||range.is_closed());
_upbGentor.setRange(range);
@@ -88,7 +88,7 @@
return _last;
}
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl/functors.hpp (original)
+++ sandbox/itl/boost/validate/itl/functors.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/itl/iterator.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename SourceT, typename TargetT>
@@ -26,7 +26,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- itl::clear(collected);
+ icl::clear(collected);
ITL_const_FORALL(typename SourceT, item_, items)
collected.insert(*item_);
}
@@ -41,7 +41,7 @@
void operator()(TargetT& collected, const SourceT& items)
{
typedef typename TargetT::value_type target_value_type;
- itl::clear(collected);
+ icl::clear(collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
prior_ = collected.insert(prior_, *item_);
@@ -56,8 +56,8 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- itl::clear(collected);
- std::copy(items.begin(), items.end(), itl::inserter(collected, collected.end()));
+ icl::clear(collected);
+ std::copy(items.begin(), items.end(), icl::inserter(collected, collected.end()));
}
};
@@ -70,9 +70,9 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- itl::clear(collected);
+ icl::clear(collected);
ITL_const_FORALL(typename SourceT, item_, items)
- //JODO itl::add(collected, *item_);
+ //JODO icl::add(collected, *item_);
collected.add(*item_);
}
};
@@ -85,7 +85,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- itl::clear(collected);
+ icl::clear(collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
//JODO prior_ = add(collected, prior_, *item_);
@@ -101,14 +101,14 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- itl::clear(collected);
- std::copy(items.begin(), items.end(), itl::adder(collected, collected.end()));
+ icl::clear(collected);
+ std::copy(items.begin(), items.end(), icl::adder(collected, collected.end()));
}
};
template<>
inline std::string binary_template_to_string<copy_addition>::apply() { return "c+"; }
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_FUNCTORS_HPP_JOFA_091004
\ No newline at end of file
Modified: sandbox/itl/boost/validate/laws/algo_equivalence.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/algo_equivalence.hpp (original)
+++ sandbox/itl/boost/validate/laws/algo_equivalence.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/predicates.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -207,7 +207,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_MINOR_SET_LAWS_HPP_JOFA_070411
Modified: sandbox/itl/boost/validate/laws/atomic_equivalence.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/atomic_equivalence.hpp (original)
+++ sandbox/itl/boost/validate/laws/atomic_equivalence.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/itl/detail/interval_morphism.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ----------------------------------------------------------------------------+
@@ -39,8 +39,8 @@
typename TargetsT,
template<class,class,template<class>class>class Algorithm,
template<class>class TargetIterator = std::insert_iterator,
- template<class,class>class Atomizer = itl::segmental::atomizer,
- template<class>class Equality = itl::std_equal >
+ template<class,class>class Atomizer = icl::segmental::atomizer,
+ template<class>class Equality = icl::std_equal >
class UnaryAtomicEquivalence :
public Law<UnaryAtomicEquivalence<SegmentsT, TargetsT,
Algorithm, TargetIterator,
@@ -124,8 +124,8 @@
template <typename SegmentsT,
typename TargetsT,
template<class,class>class Algorithm,
- template<class,class>class Atomizer = itl::segmental::atomizer,
- template<class>class Equality = itl::std_equal >
+ template<class,class>class Atomizer = icl::segmental::atomizer,
+ template<class>class Equality = icl::std_equal >
class UnaryAtomicEquivalence2 :
public Law<UnaryAtomicEquivalence2<SegmentsT, TargetsT,
Algorithm, Atomizer, Equality>,
@@ -213,8 +213,8 @@
typename TargetsT,
template<class,class,template<class>class>class Algorithm,
template<class>class TargetIterator = std::insert_iterator,
- template<class,class>class Atomizer = itl::segmental::atomizer,
- template<class>class Equality = itl::std_equal >
+ template<class,class>class Atomizer = icl::segmental::atomizer,
+ template<class>class Equality = icl::std_equal >
class BinaryAtomicEquivalence :
public Law<BinaryAtomicEquivalence<SegmentsT, TargetsT,
Algorithm, TargetIterator,
@@ -282,7 +282,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_LAWS_ATOMIC_EQUIVALENCE_HPP_JOFA_091124
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/detail/interval_morphism.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ---------------------------------------------------------------------------
@@ -213,7 +213,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_ELEMENT_ORDER_HPP_JOFA_090202
Modified: sandbox/itl/boost/validate/laws/function_equality.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/function_equality.hpp (original)
+++ sandbox/itl/boost/validate/laws/function_equality.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/predicates.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// -----------------------------------------------------------------------------
@@ -29,7 +29,7 @@
template <typename SourceT, typename TargetT,// domain, codomain types of f,g
template<class,class>class Function_f,
template<class,class>class Function_g,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class FunctionEquality :
public Law<FunctionEquality<SourceT,TargetT,Function_f,Function_g,Equality>,
LOKI_TYPELIST_1(SourceT), LOKI_TYPELIST_2(TargetT,TargetT)>
@@ -100,7 +100,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_FUNCTION_EQUALITY_HPP_JOFA_091005
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// An InducedRelation can be represented as a triangular commuting diagram
// where f is a unary function and R a binary predicate or relation
@@ -105,7 +105,7 @@
}; //class InducedRelation
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_INDUCED_RELATION_HPP_JOFA_090204
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,12 +14,12 @@
#include <boost/validate/laws/law.hpp>
#include <boost/itl/functors.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type,
template<class>class Combiner = inplace_plus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceNaturalInversion
: public Law<InplaceNaturalInversion<Type,Combiner,Equality>,
LOKI_TYPELIST_1(Type), LOKI_TYPELIST_2(Type,Type)>
@@ -69,7 +69,7 @@
template <typename Type,
template<class>class Combiner = inplace_plus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceInverseExistence
: public Law<InplaceInverseExistence<Type,Combiner,Equality>,
LOKI_TYPELIST_1(Type), LOKI_TYPELIST_2(Type,Type)>
@@ -124,7 +124,7 @@
template <typename Type,
template<class>class Combiner = inplace_plus,
template<class>class Inverter = inplace_minus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceNaiveInversion
: public Law<InplaceNaiveInversion<Type,Combiner,Inverter,Equality>,
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -176,7 +176,7 @@
template <typename Type,
template<class>class Combiner = inplace_plus,
template<class>class Inverter = inplace_minus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class DisjointNaiveInversion
: public Law<DisjointNaiveInversion<Type,Combiner,Inverter,Equality>,
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -243,7 +243,7 @@
template <typename Type,
template<class>class Combiner = inplace_plus,
template<class>class Inverter = inplace_minus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class JointInverseExistence
: public Law<JointInverseExistence<Type,Combiner,Inverter,Equality>,
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -306,7 +306,7 @@
size_t size()const { return value_size<Type>::apply(this->template getInputValue<operand_a>()); }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_INVERSION_LAWS_HPP_JOFA_071124
Modified: sandbox/itl/boost/validate/laws/law.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/law.hpp (original)
+++ sandbox/itl/boost/validate/laws/law.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#pragma warning(disable:4717) // ::size' : recursive on all control paths, function will cause runtime stack overflow
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** \brief An abstract class template Law
@@ -130,7 +130,7 @@
enum InputVarIndex { operand_a, operand_b, operand_c, operand_d, operand_e };
enum OutputVarIndex { lhs_result, rhs_result };
-}} // namespace itl boost
+}} // namespace icl boost
#ifdef BOOST_MSVC
#pragma warning(pop)
Modified: sandbox/itl/boost/validate/laws/law_violations.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/law_violations.hpp (original)
+++ sandbox/itl/boost/validate/laws/law_violations.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/set.hpp>
#include <boost/validate/loki_xt/Tuple.h>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class LawViolationsI
@@ -96,7 +96,7 @@
{
public:
typedef LawT LawType;
- typedef typename itl::set<LawType> ViolationSet;
+ typedef typename icl::set<LawType> ViolationSet;
typedef typename ViolationSet::size_type size_type;
typedef typename ViolationSet::iterator iterator;
@@ -146,7 +146,7 @@
iterator end() { return _violations.end(); }
const_iterator end()const { return _violations.begin(); }
- void clear() { itl::clear(_violations); }
+ void clear() { icl::clear(_violations); }
bool empty()const { return ITL_FUN_REN(empty, is_empty, _violations); }
size_type size()const { return _violations.size(); }
@@ -175,11 +175,11 @@
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream, const PolyLawViolations& object)
{
- return stream << "operator<<: not implemented for itl::PolyLawViolations!";
+ return stream << "operator<<: not implemented for icl::PolyLawViolations!";
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif //BOOST_ITL_LAW_VIOLATIONS_HPP_JOFA_070411
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,11 +14,11 @@
#include <boost/validate/laws/law.hpp>
#include <boost/itl/functors.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ---------------------------------------------------------------------------
- template <typename MapT, template<class>class Equality = itl::std_equal>
+ template <typename MapT, template<class>class Equality = icl::std_equal>
class SectionAbsorbtion
: public Law<SectionAbsorbtion<MapT>,
LOKI_TYPELIST_2(MapT, typename MapT::set_type), LOKI_TYPELIST_2(MapT,MapT)>
@@ -164,7 +164,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_MAP_LAWS_HPP_JOFA_071124
Modified: sandbox/itl/boost/validate/laws/minor_set_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/minor_set_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/minor_set_laws.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/predicates.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -207,7 +207,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_MINOR_SET_LAWS_HPP_JOFA_070411
Modified: sandbox/itl/boost/validate/laws/monoid.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/monoid.hpp (original)
+++ sandbox/itl/boost/validate/laws/monoid.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/predicates.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/* Monoid: (M,+,0) with .+.: M x M -> M has these axioms
@@ -197,7 +197,7 @@
template <typename Type,
template<class>class Accumulator = inplace_plus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceAssociativity
: public Law<InplaceAssociativity<Type,Accumulator,Equality>,
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -339,7 +339,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/* Orders (Orderings): .<. : M x M -> bool */
@@ -84,7 +84,7 @@
// ---------------------------------------------------------------------------
template <typename Type,
template<class>class Relation,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class Antisymmetry
: public Law<Antisymmetry<Type,Relation,Equality>,
LOKI_TYPELIST_2(Type,Type), Loki::NullType>
@@ -222,7 +222,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_ORDER_HPP_JOFA_071129
Modified: sandbox/itl/boost/validate/laws/pushouts.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/pushouts.hpp (original)
+++ sandbox/itl/boost/validate/laws/pushouts.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ---------------------------------------------------------------------------
@@ -128,7 +128,7 @@
}; //class BinaryPushout
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_PUSHOUTS_HPP_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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,13 +15,13 @@
#include <boost/validate/laws/law.hpp>
#include <boost/itl/functors.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ---------------------------------------------------------------------------
template <typename Type, template<class>class Operator1 = inplace_plus,
template<class>class Operator2 = inplace_et,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceDistributivity
: public Law<InplaceDistributivity<Type,Operator1,Operator2,Equality>,
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -122,7 +122,7 @@
template <typename Type, template<class>class Operator1 = inplace_plus,
template<class>class Operator2 = inplace_et,
template<class>class Subtraction = inplace_minus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceDeMorgan
: public Law<InplaceDeMorgan<Type,Operator1,Operator2,Subtraction,Equality>,
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -232,7 +232,7 @@
template <typename Type,
template<class>class Operator1 = inplace_plus,
template<class>class Operator2 = inplace_minus,
- template<class>class Equality = itl::std_equal>
+ template<class>class Equality = icl::std_equal>
class InplaceRightDistributivity
: public Law<InplaceRightDistributivity<Type,Operator1,Operator2>,
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -325,7 +325,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_SET_LAWS_HPP_JOFA_071124
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/detail/interval_morphism.hpp>
#include <boost/validate/laws/law.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ---------------------------------------------------------------------------
@@ -214,7 +214,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_SUBSET_ORDERING_HPP_JOFA_090202
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,15 +14,15 @@
#include <boost/validate/laws/law.hpp>
#include <boost/itl/functors.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
// ---------------------------------------------------------------------------
template <typename Type,
- template<class>class Addition = itl::inplace_plus,
- template<class>class Subtraction = itl::inplace_minus,
- template<class>class Intersection = itl::inplace_et,
- template<class>class Equality = itl::std_equal>
+ template<class>class Addition = icl::inplace_plus,
+ template<class>class Subtraction = icl::inplace_minus,
+ template<class>class Intersection = icl::inplace_et,
+ template<class>class Equality = icl::std_equal>
class InplaceSymmetricDifference
: public Law<InplaceSymmetricDifference<Type>,
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -119,7 +119,7 @@
};
// ---------------------------------------------------------------------------
- template <typename Type, template<class>class Equality = itl::std_equal>
+ template <typename Type, template<class>class Equality = icl::std_equal>
class InplaceFlip
: public Law<InplaceFlip<Type>,
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -198,7 +198,7 @@
}
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_SYMMETRIC_DIFFERENCE_HPP_JOFA_071124
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -740,7 +740,7 @@
static std::string Do(const TupleT& obj)
{
- return boost::itl::to_string<HeadType>::apply(get<0>(obj));
+ return boost::icl::to_string<HeadType>::apply(get<0>(obj));
}
};
@@ -752,7 +752,7 @@
static std::string Do(const TupleT& obj)
{
- return boost::itl::to_string<HeadType>::apply(get<0>(obj))
+ return boost::icl::to_string<HeadType>::apply(get<0>(obj))
+ ", " + Stringer<TailClass, i-1>::Do(obj);
}
};
@@ -832,7 +832,7 @@
{
static std::string apply(const SourceT& src)
{
- return boost::itl::to_string<SourceT>::apply(src);
+ return boost::icl::to_string<SourceT>::apply(src);
}
};
// ---------------------------------------------------------------------------
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -200,7 +200,7 @@
static std::string Do(H& obj)
{
- return itl::value<HeadType>::to_string(get<0>(obj));
+ return icl::value<HeadType>::to_string(get<0>(obj));
}
};
@@ -212,7 +212,7 @@
static std::string Do(H& obj)
{
- return itl::value<HeadType>::to_string(get<0>(obj))
+ return icl::value<HeadType>::to_string(get<0>(obj))
+ ", " + Stringer<TailClass, i-1>::Do(obj);
}
};
@@ -281,7 +281,7 @@
{
static std::string apply(const SourceT& src)
{
- return itl::value<SourceT>::to_string(src);
+ return icl::value<SourceT>::to_string(src);
}
};
Modified: sandbox/itl/boost/validate/std/algorithm/copy.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/copy.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/copy.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <algorithm>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//------------------------------------------------------------------------------
@@ -146,7 +146,7 @@
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_STD_ALGORITHM_COPY_HPP_JOFA_091124
Modified: sandbox/itl/boost/validate/std/algorithm/find.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/find.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/find.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <algorithm>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//------------------------------------------------------------------------------
@@ -255,7 +255,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_STD_ALGORITHM_FIND_HPP_JOFA_091205
Modified: sandbox/itl/boost/validate/std/algorithm/relation.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/relation.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/relation.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <algorithm>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//- equal ----------------------------------------------------------------------
@@ -161,7 +161,7 @@
static std::string struct_abbreviation(){ return "C=b"; }
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_STD_ALGORITHM_RELATION_HPP_JOFA_091202
Modified: sandbox/itl/boost/validate/std/algorithm/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/set_algo.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/set_algo.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -12,7 +12,7 @@
#include <algorithm>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
@@ -216,7 +216,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_STD_ALGORITHM_SET_ALGO_HPP_JOFA_091125
Modified: sandbox/itl/boost/validate/type/bits.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/bits.hpp (original)
+++ sandbox/itl/boost/validate/type/bits.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/type_traits/is_set.hpp>
#include <boost/itl/detail/relation_state.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class NaturalT> class bits
@@ -51,7 +51,7 @@
typedef bits<unsigned long long> bits64;
template<class NaturalT>
-int inclusion_compare(itl::bits<NaturalT> left, itl::bits<NaturalT> right)
+int inclusion_compare(icl::bits<NaturalT> left, icl::bits<NaturalT> right)
{
if(0 ==(left.number() & right.number())) return inclusion::unrelated;
else if(left.number() < right.number() ) return inclusion::subset;
@@ -62,7 +62,7 @@
template<class CharType, class CharTraits, class NaturalT>
std::basic_ostream<CharType, CharTraits>& operator <<
-(std::basic_ostream<CharType, CharTraits>& stream, const itl::bits<NaturalT>& object)
+(std::basic_ostream<CharType, CharTraits>& stream, const icl::bits<NaturalT>& object)
{
return stream << object.number();
}
@@ -74,13 +74,13 @@
BOOST_STATIC_CONSTANT(bool, value = true);
};
-template <>struct type_to_string<itl::bits<unsigned char > >{static std::string apply(){ return "bit8"; }};
-template <>struct type_to_string<itl::bits<unsigned short> >{static std::string apply(){ return "bit16"; }};
-template <>struct type_to_string<itl::bits<unsigned int > >{static std::string apply(){ return "bit32"; }};
-template <>struct type_to_string<itl::bits<unsigned long > >{static std::string apply(){ return "bitl32"; }};
-template <>struct type_to_string<itl::bits<unsigned long long> >{static std::string apply(){ return "bit64"; }};
+template <>struct type_to_string<icl::bits<unsigned char > >{static std::string apply(){ return "bit8"; }};
+template <>struct type_to_string<icl::bits<unsigned short> >{static std::string apply(){ return "bit16"; }};
+template <>struct type_to_string<icl::bits<unsigned int > >{static std::string apply(){ return "bit32"; }};
+template <>struct type_to_string<icl::bits<unsigned long > >{static std::string apply(){ return "bitl32"; }};
+template <>struct type_to_string<icl::bits<unsigned long long> >{static std::string apply(){ return "bit64"; }};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_LIBS_VALIDATE_TEST_BITS_HPP_JOFA_091009
Modified: sandbox/itl/boost/validate/type/nat.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/nat.hpp (original)
+++ sandbox/itl/boost/validate/type/nat.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#define ITL_LOCATION(message) location(__FILE__,__LINE__,message)
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class cnat
@@ -54,8 +54,8 @@
//inline cnat operator + (const cnat& left, const cnat& right){return cnat(left)+=right;}
//inline cnat operator - (const cnat& left, const cnat& right){return cnat(left)-=right;}
-inline bool operator == (const boost::itl::cnat& left, const boost::itl::cnat& right){ return left.value() == right.value(); }
-inline bool operator < (const boost::itl::cnat& left, const boost::itl::cnat& right){ return left.value() < right.value(); }
+inline bool operator == (const boost::icl::cnat& left, const boost::icl::cnat& right){ return left.value() == right.value(); }
+inline bool operator < (const boost::icl::cnat& left, const boost::icl::cnat& right){ return left.value() < right.value(); }
template<>inline std::string type_to_string<cnat>::apply() { return "cnat"; }
@@ -64,10 +64,10 @@
template<class CharType, class CharTraits>
std::basic_ostream<CharType, CharTraits> &operator<<
-(std::basic_ostream<CharType, CharTraits> &stream, itl::cnat const& right)
+(std::basic_ostream<CharType, CharTraits> &stream, icl::cnat const& right)
{
return stream << right.value();
}
-}} // namespace itl boost
+}} // namespace icl boost
Modified: sandbox/itl/boost/validate/utility.hpp
==============================================================================
--- sandbox/itl/boost/validate/utility.hpp (original)
+++ sandbox/itl/boost/validate/utility.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -22,7 +22,7 @@
case IdentityHandlerType::total_enricher: return new validater_Template<itl_Map<domain_Type,codomain_Type,total_enricher> >;
-namespace boost{namespace itl
+namespace boost{namespace icl
{
std::string location(const std::string& file, int line, const std::string& message)
{
@@ -48,7 +48,7 @@
);
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_UTILITY_HPP_JOFA_090203
Modified: sandbox/itl/boost/validate/validater/abelian_monoid_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/abelian_monoid_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/abelian_monoid_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/validate/validater/concept_validater.hpp>
#include <boost/validate/validater/monoid_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
typedef WeightedNumberGentor<int> ChoiceT;
@@ -54,7 +54,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_VALIDATE_VALIDATER_ABELIAN_MONOID_VALIDATER_HPP_JOFA_100501
Modified: sandbox/itl/boost/validate/validater/bit_collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/bit_collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/bit_collector_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/concept_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -85,19 +85,19 @@
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type, inplace_bit_add, inplace_bit_subtract, inplace_bit_and> >;
case inplaceFlip: return new LawValidater<InplaceFlip<Type> >;
case inplaceEtDistributivity:
- if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
+ if(icl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceDistributivity<Type, inplace_bit_and, inplace_bit_add, element_equal> >;
else return new LawValidater<InplaceDistributivity<Type, inplace_bit_and, inplace_bit_add, std_equal> >;
case inplacePlusDashRightDistrib:
- if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
+ if(icl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_add, inplace_bit_subtract, element_equal> >;
else return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_add, inplace_bit_subtract, std_equal> >;
case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_and, inplace_bit_subtract> >;
- case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_bit_add, inplace_bit_and, inplace_bit_subtract, itl::std_equal> >;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_bit_add, inplace_bit_and, inplace_bit_subtract, icl::std_equal> >;
case inplaceEtDeMorgan:
- if(itl::is_interval_splitter<Type>::value || itl::is_interval_separator<Type>::value)
- return new LawValidater<InplaceDeMorgan<Type, inplace_bit_and, inplace_bit_add, inplace_bit_subtract, itl::element_equal> >;
- else return new LawValidater<InplaceDeMorgan<Type, inplace_bit_and, inplace_bit_add, inplace_bit_subtract, itl::std_equal> >;
+ if(icl::is_interval_splitter<Type>::value || icl::is_interval_separator<Type>::value)
+ return new LawValidater<InplaceDeMorgan<Type, inplace_bit_and, inplace_bit_add, inplace_bit_subtract, icl::element_equal> >;
+ else return new LawValidater<InplaceDeMorgan<Type, inplace_bit_and, inplace_bit_add, inplace_bit_subtract, icl::std_equal> >;
default: return NULL;
}
@@ -108,6 +108,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_VALIDATER_BIT_COLLECTOR_VALIDATER_HPP_JOFA_091009
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -24,7 +24,7 @@
#pragma warning(disable:4127) // conditional expression is constant
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -90,19 +90,19 @@
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type> >;
case inplaceFlip: return new LawValidater<InplaceFlip<Type> >;
case inplaceEtDistributivity:
- if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
+ if(icl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal> >;
else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal> >;
case inplacePlusDashRightDistrib:
- if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
+ if(icl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal> >;
else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal> >;
case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus> >;
- case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal> >;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, icl::std_equal> >;
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> >;
- else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::std_equal> >;
+ if(icl::is_interval_splitter<Type>::value || icl::is_interval_separator<Type>::value)
+ return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, icl::element_equal> >;
+ else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, icl::std_equal> >;
default: return NULL;
}
@@ -113,7 +113,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#ifdef BOOST_MSVC
#pragma warning(pop)
Modified: sandbox/itl/boost/validate/validater/concept_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/concept_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/concept_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/itl/functors.hpp>
#include <boost/validate/validater/law_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
typedef WeightedNumberGentor<int> ChoiceT;
@@ -65,6 +65,6 @@
return share;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_VALIDATE_CONCEPT_VALIDATER_HPP_JOFA_080203
Modified: sandbox/itl/boost/validate/validater/function_equality_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/function_equality_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/function_equality_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/concept_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename SourceT, typename TargetT>
@@ -63,5 +63,5 @@
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -21,7 +21,7 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/concept_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -99,5 +99,5 @@
ChoiceT _lawChoice;
};
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/concept_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -61,7 +61,7 @@
}; //class itl_induced_relations_validater
-}} // namespace itl boost
+}} // namespace icl boost
#endif BOOST_ITL_VALIDATE_VALIDATER_ITL_INDUCED_RELATIONS_HPP_JOFA_090304
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/validate/validater/strict_weak_order_validater.hpp>
#include <boost/validate/validater/partial_order_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -26,7 +26,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, icl::sub_super_set, icl::element_equal> ContainedInValidaterT;
enum Laws
{
@@ -68,5 +68,5 @@
ContainedInValidaterT _containedInValidater;
};
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -23,7 +23,7 @@
#pragma warning(disable:4127) // conditional expression is constant
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -92,19 +92,19 @@
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type> >;
case inplaceFlip: return new LawValidater<InplaceFlip<Type> >;
case inplaceEtDistributivity:
- if(itl::is_interval_splitter<Type>::value)
+ if(icl::is_interval_splitter<Type>::value)
return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal> >;
else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal> >;
case inplacePlusDashRightDistrib:
- if(itl::is_interval_splitter<Type>::value)
+ if(icl::is_interval_splitter<Type>::value)
return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal> >;
else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal> >;
case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus> >;
- case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal> >;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, icl::std_equal> >;
case inplaceEtDeMorgan:
- if(itl::is_interval_splitter<Type>::value || itl::is_interval_separator<Type>::value)
- return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, inplace_minus, itl::element_equal> >;
- else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, inplace_minus, itl::std_equal> >;
+ if(icl::is_interval_splitter<Type>::value || icl::is_interval_separator<Type>::value)
+ return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, inplace_minus, icl::element_equal> >;
+ else return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, inplace_minus, icl::std_equal> >;
default: return NULL;
}
@@ -115,7 +115,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#ifdef BOOST_MSVC
#pragma warning(pop)
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -22,11 +22,11 @@
#include <boost/validate/laws/monoid.hpp>
#include <boost/validate/laws/law_violations.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
- typedef itl::map<std::string, validation_counts> ValidationCounterT;
- typedef itl::map<std::string, int> ViolationCounterT;
- typedef itl::map<std::string, PolyLawViolations> ViolationMapT;
+ typedef icl::map<std::string, validation_counts> ValidationCounterT;
+ typedef icl::map<std::string, int> ViolationCounterT;
+ typedef icl::map<std::string, PolyLawViolations> ViolationMapT;
/** \brief An interface for a test machine. */
class LawValidaterI
@@ -136,9 +136,9 @@
template <class LawT, template<typename>class GentorT>
void LawValidater<LawT, GentorT>::init()
{
- itl::clear(_frequencies);
+ icl::clear(_frequencies);
_lawViolations.clear();
- itl::clear(_violations);
+ icl::clear(_violations);
}
// Runs law_instance_count * repeat_count validations on the law LawT
@@ -235,7 +235,7 @@
std::cout << "Law successfully validated for " << _trials_count << " cases" << std::endl;
}
-}} // namespace itl boost
+}} // namespace icl boost
// ----------------------------------------------------------------------------
Modified: sandbox/itl/boost/validate/validater/monoid_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/monoid_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/monoid_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include <boost/validate/validater/concept_validater.hpp>
#include <boost/validate/laws/monoid.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -50,7 +50,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_VALIDATE_VALIDATER_MONOID_VALIDATER_HPP_JOFA_100501
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,10 +18,10 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/concept_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
- 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 = icl::std_equal>
class partial_order_validater : public concept_validater
{
public:
@@ -62,5 +62,5 @@
ChoiceT _lawChoice;
};
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -26,7 +26,7 @@
#pragma warning(disable:4127) // conditional expression is constant
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -124,7 +124,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#ifdef BOOST_MSVC
#pragma warning(pop)
Modified: sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,10 +19,10 @@
#include <boost/validate/std/algorithm/relation.hpp>
#include <boost/validate/std/algorithm/find.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
-template <typename Type, typename TargetT = itl::list<typename Type::value_type> >
+template <typename Type, typename TargetT = icl::list<typename Type::value_type> >
class sorted_associative_back_validater : public concept_validater
{
public:
@@ -109,6 +109,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_VALIDATER_SORTED_ASSOCIATIVE_BACK_VALIDATER_HPP_JOFA_091202
Modified: sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -21,10 +21,10 @@
#include <boost/validate/std/algorithm/find.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
-template <typename Type, typename TargetT = itl::list<typename Type::value_type> >
+template <typename Type, typename TargetT = icl::list<typename Type::value_type> >
class sorted_associative_validater : public concept_validater
{
public:
@@ -111,6 +111,6 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_VALIDATE_VALIDATER_SORTED_ASSOCIATIVE_VALIDATER_HPP_JOFA_091125
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,7 +18,7 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/concept_validater.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type, template<class>class Relation>
@@ -63,5 +63,5 @@
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -24,7 +24,7 @@
#pragma warning(disable:4127) // conditional expression is constant
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -91,7 +91,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#ifdef BOOST_MSVC
#pragma warning(pop)
Modified: sandbox/itl/boost/validate/validation_counts.hpp
==============================================================================
--- sandbox/itl/boost/validate/validation_counts.hpp (original)
+++ sandbox/itl/boost/validate/validation_counts.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#define BOOST_ITL_VALIDATION_COUNTS_HPP_JOFA_090713
-namespace boost{namespace itl
+namespace boost{namespace icl
{
class validation_counts
@@ -48,6 +48,6 @@
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_VALIDATION_COUNTS_HPP_JOFA_090713
Modified: sandbox/itl/libs/itl/doxy_doc/doxygen_input/pages/doxygen_mainpage.hpp
==============================================================================
--- sandbox/itl/libs/itl/doxy_doc/doxygen_input/pages/doxygen_mainpage.hpp (original)
+++ sandbox/itl/libs/itl/doxy_doc/doxygen_input/pages/doxygen_mainpage.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,9 +11,9 @@
#define BOOST_ITL_DOXYGEN_MAINPAGE_HPP_JOFA_091216
/**
-\mainpage Interval Template Library
+\mainpage Boost Interval Container Library
-\section header_sec Interval Template Library
+\section header_sec Boost Interval Container Library
Author: Joachim Faulhaber\n
Copyright (c) 2007-2009: Joachim Faulhaber\n
@@ -25,7 +25,7 @@
\section overview_sec Overview
-The <b>Interval Template Library (ITL+)</b> is a collection of
+The <b>Boost Interval Container Library (ITL+)</b> is a collection of
generic c++ class templates for computations on intervals,
interval containers, large bitsets and generalized crosstables or cubes.
@@ -79,10 +79,10 @@
project section</a>
of the boost book documentation.
-<li>itl::add_iterator, and itl::insert_iterator
+<li>icl::add_iterator, and icl::insert_iterator
To copy or tranform data from std::containers of intervals or segments into
-interval containers you can use an itl::insert_iterator or an itl::add_iterator.
+interval containers you can use an icl::insert_iterator or an icl::add_iterator.
See examples
<a href="http://www.herold-faulhaber.de/boost_itl/doc/libs/itl/doc/html/boost_itl/examples/std_copy.html">
std_copy</a> and
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -62,7 +62,7 @@
using namespace std;
using namespace boost::posix_time;
-using namespace boost::itl;
+using namespace boost::icl;
// Type set<string> collects the names of party guests. Since std::set is
// a model of the itl's set concept, the concept provides an operator +=
@@ -122,7 +122,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample boost_party.cpp <<\n";
+ cout << ">>Interval Container Library: Sample boost_party.cpp <<\n";
cout << "-------------------------------------------------------\n";
boost_party();
return 0;
@@ -130,7 +130,7 @@
// Program output:
/*-----------------------------------------------------------------------------
->> Interval Template Library: Sample boost_party.cpp <<
+>>Interval Container Library: Sample boost_party.cpp <<
-------------------------------------------------------
----- History of party guests -------------------------
[2008-May-20 19:30:00, 2008-May-20 20:10:00): Harry Mary
Modified: sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp (original)
+++ sandbox/itl/libs/itl/example/custom_interval_/custom_interval.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2010: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -24,7 +24,7 @@
#include <boost/itl/interval_set.hpp>
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
// Here is a typical class that may model intervals in your application.
class MyInterval
@@ -80,7 +80,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample custom_interval.cpp <<\n";
+ cout << ">>Interval Container Library: Sample custom_interval.cpp <<\n";
cout << "-----------------------------------------------------------\n";
cout << "This program uses a user defined interval class:\n";
custom_interval();
@@ -89,7 +89,7 @@
// Program output:
/*-----------------------------------------------------------------------------
->> Interval Template Library: Sample custom_interval.cpp <<
+>>Interval Container Library: Sample custom_interval.cpp <<
-----------------------------------------------------------
This program uses a user defined interval class:
{[1, 9)}
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -27,11 +27,11 @@
#include "../toytime.hpp"
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
int main()
{
- cout << ">> Interval Template Library: Sample interval.cpp <<\n";
+ cout << ">>Interval Container Library: Sample interval.cpp <<\n";
cout << "----------------------------------------------------\n";
discrete_interval<int> int_interval
@@ -63,7 +63,7 @@
// Program output:
-//>> Interval Template Library: Sample interval.cpp <<
+//>>Interval Container Library: Sample interval.cpp <<
//----------------------------------------------------
// discrete_interval<int>: [3,7]
//continuous_interval<double>: [0.707107,1.41421) does NOT contain sqrt(2)
Modified: sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -30,7 +30,7 @@
#include "../toytime.hpp"
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
void interval_container_basics()
{
@@ -88,7 +88,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample interval_container.cpp <<\n";
+ cout << ">>Interval Container Library: Sample interval_container.cpp <<\n";
cout << "--------------------------------------------------------------\n";
interval_container_basics();
return 0;
@@ -97,7 +97,7 @@
// Program output:
/* ----------------------------------------------------------------------------
->> Interval Template Library: Sample interval_container.cpp <<
+>>Interval Container Library: Sample interval_container.cpp <<
--------------------------------------------------------------
Joined times :[mon:20:00,wed:10:00)[wed:18:00,wed:21:00)
Separate times:[mon:20:00,wed:07:00)[wed:07:00,wed:10:00)[wed:18:00,wed:21:00)
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void instructions()
{
@@ -92,7 +92,7 @@
break;
case 'j':
{
- itl::join(m1);
+ icl::join(m1);
cout << "{" << m1 << "}" << endl;
}
break;
@@ -123,7 +123,7 @@
int main()
{
- cout << ">> Interval Template Library: Test itvset_shell.cpp <<\n";
+ cout << ">>Interval Container Library: Test itvset_shell.cpp <<\n";
cout << "------------------------------------------------------\n";
setTestShell< interval_set<int> >();
Modified: sandbox/itl/libs/itl/example/large_bitset_/bits.hpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/bits.hpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/bits.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -56,7 +56,7 @@
} // mini
//[mini_bits_is_set
-namespace boost { namespace itl
+namespace boost { namespace icl
{
template<class NaturalT>
struct is_set<mini::bits<NaturalT> >
Modified: sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/large_bitset.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -34,7 +34,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
using namespace mini;
//]
@@ -157,7 +157,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample large_bitset.cpp <<\n";
+ cout << ">>Interval Container Library: Sample large_bitset.cpp <<\n";
cout << "--------------------------------------------------------\n";
test_large();
test_small();
Modified: sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -71,9 +71,9 @@
{
public:
//[large_bitset_associated_types
- typedef boost::itl::interval_map
- <DomainT, BitSetT, boost::itl::partial_absorber,
- std::less, boost::itl::inplace_bit_add, boost::itl::inplace_bit_and> interval_bitmap_type;
+ typedef boost::icl::interval_map
+ <DomainT, BitSetT, boost::icl::partial_absorber,
+ std::less, boost::icl::inplace_bit_add, boost::icl::inplace_bit_and> interval_bitmap_type;
typedef DomainT domain_type;
typedef DomainT element_type;
@@ -113,7 +113,7 @@
//]
//[large_bitset_demo_functions
- size_t interval_count()const { return itl::interval_count(_map); }
+ size_t interval_count()const { return icl::interval_count(_map); }
void show_segments()const
{
@@ -131,7 +131,7 @@
typename interval_bitmap_type::const_iterator iter = _map.begin();
while(iter != _map.end())
{
- element_type fst = itl::first(iter->first), lst = itl::last(iter->first);
+ element_type fst = icl::first(iter->first), lst = icl::last(iter->first);
for(element_type chunk = fst; chunk <= lst; chunk++)
std::cout << iter->second.as_string(off_on) << std::endl;
++iter;
@@ -165,10 +165,10 @@
//[large_bitset_segment_apply
large_bitset& segment_apply(segment_combiner combine, const interval_type& operand)
{ // same as
- element_type base = itl::first(operand) >> shift, // itl::first(operand) / divisor
- ceil = itl::last (operand) >> shift; // itl::last (operand) / divisor
- word_type base_rest = itl::first(operand) & mask , // itl::first(operand) % divisor
- ceil_rest = itl::last (operand) & mask ; // itl::last (operand) % divisor
+ element_type base = icl::first(operand) >> shift, // icl::first(operand) / divisor
+ ceil = icl::last (operand) >> shift; // icl::last (operand) / divisor
+ word_type base_rest = icl::first(operand) & mask , // icl::first(operand) % divisor
+ ceil_rest = icl::last (operand) & mask ; // icl::last (operand) % divisor
if(base == ceil) // [first, last] are within one bitset (chunk)
(this->*combine)(base, base+1, bitset_type( to_upper_from(base_rest)
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -34,7 +34,7 @@
using namespace std;
using namespace boost::gregorian;
-using namespace boost::itl;
+using namespace boost::icl;
// Function weekends returns the interval_set of weekends that are contained in
@@ -158,7 +158,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample man_power.cpp <<\n";
+ cout << ">>Interval Container Library: Sample man_power.cpp <<\n";
cout << "---------------------------------------------------------------\n";
man_power();
return 0;
@@ -166,7 +166,7 @@
// Program output:
/*
->> Interval Template Library: Sample man_power.cpp <<
+>>Interval Container Library: Sample man_power.cpp <<
---------------------------------------------------------------
2008-Aug-01 - 2008-Oct-31 available man-power:
---------------------------------------------------------------
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -38,7 +38,7 @@
using namespace std;
using namespace boost::gregorian;
-using namespace boost::itl;
+using namespace boost::icl;
typedef split_interval_set<boost::gregorian::date> date_grid;
@@ -113,7 +113,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample month_and_time_grid.cpp <<\n";
+ cout << ">>Interval Container Library: Sample month_and_time_grid.cpp <<\n";
cout << "---------------------------------------------------------------\n";
month_and_time_grid();
return 0;
@@ -121,7 +121,7 @@
// Program output:
/*
->> Interval Template Library: Sample month_and_time_grid.cpp <<
+>>Interval Container Library: Sample month_and_time_grid.cpp <<
---------------------------------------------------------------
interval : 2008-Jun-22 - 2008-Aug-21 month and week partitions:
---------------------------------------------------------------
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -31,7 +31,7 @@
#include <boost/itl/split_interval_map.hpp>
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
/* The most simple example of an interval_map is an overlap counter.
@@ -81,7 +81,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample overlap_counter.cpp <<\n";
+ cout << ">>Interval Container Library: Sample overlap_counter.cpp <<\n";
cout << "-----------------------------------------------------------\n";
overlap_counter();
return 0;
@@ -89,7 +89,7 @@
// Program output:
-// >> Interval Template Library: Sample overlap_counter.cpp <<
+// >>Interval Container Library: Sample overlap_counter.cpp <<
// -----------------------------------------------------------
// -- adding [4,8) -----------------------------------------
// in interval [4,8) intervals do not overlap
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -13,7 +13,7 @@
#include "../toytime.hpp"
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
/**
@@ -96,7 +96,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample party.cpp <<\n";
+ cout << ">>Interval Container Library: Sample party.cpp <<\n";
cout << "-------------------------------------------------------\n";
party();
return 0;
@@ -104,7 +104,7 @@
// Program output:
-// >> Interval Template Library: Sample party.cpp <<
+// >>Interval Container Library: Sample party.cpp <<
// -------------------------------------------------
// [sun:19:30,sun:20:10): Harry Mary
// [sun:20:10,sun:22:15): Diana Harry Mary Susan
Modified: sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -34,7 +34,7 @@
using namespace std;
using namespace boost::posix_time;
-using namespace boost::itl;
+using namespace boost::icl;
class counted_sum
@@ -114,7 +114,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample partys_height_average.cpp <<\n";
+ cout << ">>Interval Container Library: Sample partys_height_average.cpp <<\n";
cout << "------------------------------------------------------------------\n";
partys_height_average();
return 0;
@@ -122,7 +122,7 @@
// Program output:
/*-----------------------------------------------------------------------------
->> Interval Template Library: Sample partys_height_average.cpp <<
+>>Interval Container Library: Sample partys_height_average.cpp <<
------------------------------------------------------------------
-------------- History of average guest height -------------------
[2008-May-20 19:30:00 - 2008-May-20 20:10:00): 173 cm = 5.66 ft
Modified: sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -38,7 +38,7 @@
using namespace std;
using namespace boost::posix_time;
-using namespace boost::itl;
+using namespace boost::icl;
// A party's height shall be defined as the maximum height of all guests ;-)
@@ -135,7 +135,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample partys_tallest_guests.cpp <<\n";
+ cout << ">>Interval Container Library: Sample partys_tallest_guests.cpp <<\n";
cout << "------------------------------------------------------------------\n";
partys_height();
partys_split_height();
@@ -144,7 +144,7 @@
// Program output:
/*-----------------------------------------------------------------------------
->> Interval Template Library: Sample partys_tallest_guests.cpp <<
+>>Interval Container Library: Sample partys_tallest_guests.cpp <<
------------------------------------------------------------------
-------------- History of maximum guest height -------------------
[2008-May-20 19:30:00 - 2008-May-20 22:15:00): 180 cm = 5.90551 ft
Modified: sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp (original)
+++ sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void instructions()
{
@@ -94,7 +94,7 @@
break;
case 'j':
{
- itl::join(m1);
+ icl::join(m1);
cout << "{" << m1 << "}" << endl;
}
break;
@@ -122,7 +122,7 @@
int main()
{
- cout << ">> Interval Template Library: Test splititvmap_shell.cpp <<\n";
+ cout << ">>Interval Container Library: Test splititvmap_shell.cpp <<\n";
cout << "-----------------------------------------------------------\n";
mapTestShell< interval_map<int, int> >();
Modified: sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp (original)
+++ sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -22,12 +22,12 @@
#include <vector>
#include <algorithm>
#include <boost/itl/interval_map.hpp>
-#include <boost/itl/iterator.hpp> // needed for itl::inserter and
- // itl::adder.
+#include <boost/itl/iterator.hpp> // needed for icl::inserter and
+ // icl::adder.
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
// 'make_segments' returns a vector of interval value pairs, which
// are not sorted. The values are taken from the minimal example
@@ -62,21 +62,21 @@
// We are going to 'std::copy' those segments into an interval_map:
interval_map<int,int> segmap;
- // Use an 'itl::inserter' from <boost/itl/iterator.hpp> to call
+ // Use an 'icl::inserter' from <boost/itl/iterator.hpp> to call
// insertion on the interval container.
std::copy(segments.begin(), segments.end(),
- itl::inserter(segmap, segmap.end()));
- cout << "itl::inserting: " << segmap << endl;
+ icl::inserter(segmap, segmap.end()));
+ cout << "icl::inserting: " << segmap << endl;
segmap.clear();
// When we are feeding data into interval_maps, most of the time we are
// intending to compute an aggregation result. So we are not interested
- // the std::insert semantincs but the aggregating itl::addition semantics.
- // To achieve this there is an itl::add_iterator and an itl::adder function
+ // the std::insert semantincs but the aggregating icl::addition semantics.
+ // To achieve this there is an icl::add_iterator and an icl::adder function
// provided in <boost/itl/iterator.hpp>.
std::copy(segments.begin(), segments.end(),
- itl::adder(segmap, segmap.end())); //Aggregating associated values
- cout << "itl::adding : " << segmap << endl;
+ icl::adder(segmap, segmap.end())); //Aggregating associated values
+ cout << "icl::adding : " << segmap << endl;
// In this last case, the semantics of 'std::copy' transforms to the
// generalized addition operation, that is implemented by operator
@@ -85,7 +85,7 @@
int main()
{
- cout << ">> Interval Template Library: Example std_copy.cpp <<\n";
+ cout << ">> Interval Container Library: Example std_copy.cpp <<\n";
cout << "-----------------------------------------------------------\n";
cout << "Using std::copy to fill an interval_map:\n\n";
@@ -95,13 +95,13 @@
// Program output:
/*---------------------------------------------------------
->> Interval Template Library: Example std_copy.cpp <<
+>> Interval Container Library: Example std_copy.cpp <<
-----------------------------------------------------------
Using std::copy to fill an interval_map:
input sequence: ([2,4),1)([4,5),1)([1,3),1)
-itl::inserting: {([1,5)->1)}
-itl::adding : {([1,2)->1)([2,3)->2)([3,5)->1)}
+icl::inserting: {([1,5)->1)}
+icl::adding : {([1,2)->1)([2,3)->2)([3,5)->1)}
---------------------------------------------------------*/
//]
Modified: sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp (original)
+++ sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -23,12 +23,12 @@
#include <algorithm>
#include <boost/itl/split_interval_map.hpp>
#include <boost/itl/separate_interval_set.hpp>
-#include <boost/itl/iterator.hpp> // needed for itl::inserter and
- // itl::adder.
+#include <boost/itl/iterator.hpp> // needed for icl::inserter and
+ // icl::adder.
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
// Suppose we are working with a class called MyObject, containing some
// information about interval bounds e.g. _from, _to and some data members
@@ -97,34 +97,34 @@
// Display the input
cout << "input sequence: "; show_objects(myObjects); cout << "\n\n";
- // Use an itl::inserter to fill the interval map via inserts
+ // Use an icl::inserter to fill the interval map via inserts
std::transform(myObjects.begin(), myObjects.end(),
- itl::inserter(segmap, segmap.end()),
+ icl::inserter(segmap, segmap.end()),
to_segment);
- cout << "itl::inserting: " << segmap << endl;
+ cout << "icl::inserting: " << segmap << endl;
segmap.clear();
// In order to compute aggregation results on associated values, we
- // usually want to use an itl::adder instead of an std or itl::inserter
+ // usually want to use an icl::adder instead of an std or icl::inserter
std::transform(myObjects.begin(), myObjects.end(),
- itl::adder(segmap, segmap.end()),
+ icl::adder(segmap, segmap.end()),
to_segment);
- cout << "itl::adding : " << segmap << "\n\n";
+ cout << "icl::adding : " << segmap << "\n\n";
separate_interval_set<int> segset;
std::transform(myObjects.begin(), myObjects.end(),
- itl::adder (segset, segset.end()),
- // could be a itl::inserter(segset, segset.end()), here: same effect
+ icl::adder (segset, segset.end()),
+ // could be a icl::inserter(segset, segset.end()), here: same effect
to_interval);
cout << "Using std::transform to fill a separate_interval_set:\n\n";
- cout << "itl::adding : " << segset << "\n\n";
+ cout << "icl::adding : " << segset << "\n\n";
}
int main()
{
- cout << ">> Interval Template Library: Example std_transform.cpp <<\n";
+ cout << ">> Interval Container Library: Example std_transform.cpp <<\n";
cout << "------------------------------------------------------------\n";
cout << "Using std::transform to fill a split_interval_map:\n\n";
@@ -134,18 +134,18 @@
// Program output:
/*----------------------------------------------------------
->> Interval Template Library: Example std_transform.cpp <<
+>> Interval Container Library: Example std_transform.cpp <<
------------------------------------------------------------
Using std::transform to fill a split_interval_map:
input sequence: ([2,3],1)([4,4],1)([1,2],1)
-itl::inserting: {([1,2)->1)([2,3]->1)([4,4]->1)}
-itl::adding : {([1,2)->1)([2,2]->2)((2,3]->1)([4,4]->1)}
+icl::inserting: {([1,2)->1)([2,3]->1)([4,4]->1)}
+icl::adding : {([1,2)->1)([2,2]->2)((2,3]->1)([4,4]->1)}
Using std::transform to fill a separate_interval_set:
-itl::adding : {[1,3][4,4]}
+icl::adding : {[1,3][4,4]}
----------------------------------------------------------*/
//]
Modified: sandbox/itl/libs/itl/example/toytime.hpp
==============================================================================
--- sandbox/itl/libs/itl/example/toytime.hpp (original)
+++ sandbox/itl/libs/itl/example/toytime.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,11 +13,11 @@
#pragma warning(disable:4996) // This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** Time is a toy-class to demonstrate a class that conforms the requirements of
- a template parameter for class template itl::interval.
+ a template parameter for class template icl::interval.
In real world applications you may want to use the integer representation of a
time variable. That way intervals and their containers are working most efficiently.
@@ -70,5 +70,5 @@
#pragma warning(pop)
#endif
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -39,12 +39,12 @@
using namespace std;
using namespace boost::gregorian;
-using namespace boost::itl;
+using namespace boost::icl;
-// Type itl::set<string> collects the names a user group's members. Therefore
+// Type icl::set<string> collects the names a user group's members. Therefore
// it needs to implement operator += that performs a set union on overlap of
// intervals.
-typedef boost::itl::set<string> MemberSetT;
+typedef boost::icl::set<string> MemberSetT;
// boost::gregorian::date is the domain type the interval map.
// It's key values are therefore time intervals: discrete_interval<date>. The content
@@ -162,7 +162,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample user_groups.cpp <<\n";
+ cout << ">>Interval Container Library: Sample user_groups.cpp <<\n";
cout << "-------------------------------------------------------\n";
user_groups();
return 0;
@@ -170,7 +170,7 @@
// Program output:
/*-----------------------------------------------------------------------------
->> Interval Template Library: Sample user_groups.cpp <<
+>>Interval Container Library: Sample user_groups.cpp <<
-------------------------------------------------------
----- Membership of medical staff -----------------------------------
[2008-Jan-01 - 2008-Jan-14]: Harry Mary
Modified: sandbox/itl/libs/itl/test/fastest_interval_map_/fastest_interval_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_map_/fastest_interval_map.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_map_/fastest_interval_map.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map unit test
+#define BOOST_TEST_MODULE icl::interval_map unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_interval_map_infix_/fastest_interval_map_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_map_infix_/fastest_interval_map_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_map_infix_/fastest_interval_map_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_infix unit test
+#define BOOST_TEST_MODULE icl::interval_map_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -21,7 +21,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_map_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_interval_map_infix_mixed_/fastest_interval_map_infix_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_map_infix_mixed_/fastest_interval_map_infix_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_map_infix_mixed_/fastest_interval_map_infix_mixed.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_infix_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_map_infix_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_map_mixed.hpp"
Modified: sandbox/itl/libs/itl/test/fastest_interval_map_mixed2_/fastest_interval_map_mixed2.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_map_mixed2_/fastest_interval_map_mixed2.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_map_mixed2_/fastest_interval_map_mixed2.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_map_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_map_mixed.hpp"
Modified: sandbox/itl/libs/itl/test/fastest_interval_map_mixed_/fastest_interval_map_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_map_mixed_/fastest_interval_map_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_map_mixed_/fastest_interval_map_mixed.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_map_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_map_mixed.hpp"
Modified: sandbox/itl/libs/itl/test/fastest_interval_set_/fastest_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_set_/fastest_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_set_/fastest_interval_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(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
+#define BOOST_TEST_MODULE icl::interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_interval_set_infix_/fastest_interval_set_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_set_infix_/fastest_interval_set_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_set_infix_/fastest_interval_set_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_set_infix unit test
+#define BOOST_TEST_MODULE icl::interval_set_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_interval_set_mixed_/fastest_interval_set_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_interval_set_mixed_/fastest_interval_set_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_interval_set_mixed_/fastest_interval_set_mixed.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_set_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_set_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -21,7 +21,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_set_mixed.hpp"
Modified: sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval unit test
+#define BOOST_TEST_MODULE icl::interval unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -28,7 +28,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_itl_interval_shared.hpp"
#include "../test_icl_interval.hpp"
Modified: sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::itl_map unit test
+#define BOOST_TEST_MODULE icl::itl_map unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_partial_icl_quantifier_/fastest_partial_icl_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_partial_icl_quantifier_/fastest_partial_icl_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_partial_icl_quantifier_/fastest_partial_icl_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::partial_icl_quantifier unit test
+#define BOOST_TEST_MODULE icl::partial_icl_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::partial_interval_quantifier unit test
+#define BOOST_TEST_MODULE icl::partial_interval_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_separate_interval_set_/fastest_separate_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_separate_interval_set_/fastest_separate_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_separate_interval_set_/fastest_separate_interval_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::separate_interval_set unit test
+#define BOOST_TEST_MODULE icl::separate_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_separate_interval_set_infix_/fastest_separate_interval_set_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_separate_interval_set_infix_/fastest_separate_interval_set_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_separate_interval_set_infix_/fastest_separate_interval_set_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::separate_interval_set_infix unit test
+#define BOOST_TEST_MODULE icl::separate_interval_set_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_set_interval_set_/fastest_set_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_set_interval_set_/fastest_set_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_set_interval_set_/fastest_set_interval_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::set_interval_set unit test
+#define BOOST_TEST_MODULE icl::set_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::set_itl_set unit test
+#define BOOST_TEST_MODULE icl::set_itl_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/fastest_set_itl_set_/fastest_set_itl_set_cases.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
{ itl_set_check_monoid_plus_4_bicremental_types<discrete_type_1, interval_set>();}
//MEMO: interval_set
// is used here pragmatically to be able to recycle test code for initializing
-// sets. These interval_set are then converted to itl::set by atomize.
+// sets. These interval_set are then converted to icl::set by atomize.
BOOST_AUTO_TEST_CASE
(fastest_itl_itl_set_check_abelian_monoid_plus_4_bicremental_types)
Modified: sandbox/itl/libs/itl/test/fastest_split_interval_map_/fastest_split_interval_map.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_split_interval_map_/fastest_split_interval_map.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_split_interval_map_/fastest_split_interval_map.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::split_interval_map unit test
+#define BOOST_TEST_MODULE icl::split_interval_map unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_split_interval_map_infix_/fastest_split_interval_map_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_split_interval_map_infix_/fastest_split_interval_map_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_split_interval_map_infix_/fastest_split_interval_map_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::split_interval_map_infix unit test
+#define BOOST_TEST_MODULE icl::split_interval_map_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_map_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_split_interval_set_/fastest_split_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_split_interval_set_/fastest_split_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_split_interval_set_/fastest_split_interval_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(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
+#define BOOST_TEST_MODULE icl::split_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_split_interval_set_infix_/fastest_split_interval_set_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_split_interval_set_infix_/fastest_split_interval_set_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_split_interval_set_infix_/fastest_split_interval_set_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::split_interval_set_infix unit test
+#define BOOST_TEST_MODULE icl::split_interval_set_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_total_icl_quantifier_/fastest_total_icl_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_total_icl_quantifier_/fastest_total_icl_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_total_icl_quantifier_/fastest_total_icl_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::total_icl_quantifier unit test
+#define BOOST_TEST_MODULE icl::total_icl_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_/fastest_total_interval_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_/fastest_total_interval_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_/fastest_total_interval_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::total_interval_quantifier unit test
+#define BOOST_TEST_MODULE icl::total_interval_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::casual unit test
+#define BOOST_TEST_MODULE icl::casual unit test
#include <string>
#include <vector>
#include <boost/mpl/list.hpp>
@@ -47,7 +47,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
/*CL after Proto
BOOST_AUTO_TEST_CASE(reverse_iter)
@@ -88,7 +88,7 @@
cout << "digits<string> = " << std::numeric_limits<std::string>::digits << endl;
- BOOST_CHECK_EQUAL(0 != itl::infinity<int>::value(), true);
+ BOOST_CHECK_EQUAL(0 != icl::infinity<int>::value(), true);
}
*/
@@ -144,29 +144,29 @@
continuous_interval<double> L0D = continuous_interval<double>(0.0, 0.0, interval_bounds::right_open());
continuous_interval<double> C0D = continuous_interval<double>(0.0, 0.0, interval_bounds::open());
- BOOST_CHECK_EQUAL(itl::is_empty(L0T), false);
- BOOST_CHECK_EQUAL(itl::is_empty(C0T), true);
- BOOST_CHECK_EQUAL(itl::is_empty(L0D), true);
- BOOST_CHECK_EQUAL(itl::is_empty(C0D), true);
+ BOOST_CHECK_EQUAL(icl::is_empty(L0T), false);
+ BOOST_CHECK_EQUAL(icl::is_empty(C0T), true);
+ BOOST_CHECK_EQUAL(icl::is_empty(L0D), true);
+ BOOST_CHECK_EQUAL(icl::is_empty(C0D), true);
continuous_interval<double> L0_1T = continuous_interval<double>(0.0, 1.0, interval_bounds::closed());
continuous_interval<double> L1_2T = continuous_interval<double>(1.0, 2.0, interval_bounds::closed());
- BOOST_CHECK_EQUAL(itl::exclusive_less(L0_1T, L1_2T), false);
- BOOST_CHECK_EQUAL(itl::inner_bounds(L0_1T, L1_2T) == interval_bounds::open(), true);
+ BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1T, L1_2T), false);
+ BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1T, L1_2T) == interval_bounds::open(), true);
continuous_interval<double> L0_1D = continuous_interval<double>(0.0, 1.0, interval_bounds::right_open());
- BOOST_CHECK_EQUAL(itl::exclusive_less(L0_1D, L1_2T), true);
- BOOST_CHECK_EQUAL(itl::inner_bounds(L0_1D, L1_2T) == interval_bounds::right_open(), true);
+ BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1D, L1_2T), true);
+ BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1D, L1_2T) == interval_bounds::right_open(), true);
continuous_interval<double> C1_2T = continuous_interval<double>(1.0, 2.0, interval_bounds::left_open());
- BOOST_CHECK_EQUAL(itl::exclusive_less(L0_1T, C1_2T), true);
- BOOST_CHECK_EQUAL(itl::inner_bounds(L0_1T, C1_2T) == interval_bounds::left_open(), true);
+ BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1T, C1_2T), true);
+ BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1T, C1_2T) == interval_bounds::left_open(), true);
- BOOST_CHECK_EQUAL(itl::exclusive_less(L0_1D, C1_2T), true);
- BOOST_CHECK_EQUAL(itl::inner_bounds(L0_1D, C1_2T) == interval_bounds::closed(), true);
+ BOOST_CHECK_EQUAL(icl::exclusive_less(L0_1D, C1_2T), true);
+ BOOST_CHECK_EQUAL(icl::inner_bounds(L0_1D, C1_2T) == interval_bounds::closed(), true);
- //BOOST_CHECK_EQUAL(itl::is_empty(conterval), true);
+ //BOOST_CHECK_EQUAL(icl::is_empty(conterval), true);
}
BOOST_AUTO_TEST_CASE(test_interval_bounds)
@@ -174,10 +174,10 @@
continuous_interval<double> L0_1T = continuous_interval<double>(0.0, 1.0, interval_bounds::closed());
continuous_interval<double> L0_1D = continuous_interval<double>(0.0, 1.0, interval_bounds::right_open());
- cout << "itl::right(L0_1T) = " << static_cast<int>(itl::right(L0_1T.bounds()).bits()) << endl;
- cout << "itl::right(L0_1D) = " << static_cast<int>(itl::right(L0_1D.bounds()).bits()) << endl;
+ cout << "icl::right(L0_1T) = " << static_cast<int>(icl::right(L0_1T.bounds()).bits()) << endl;
+ cout << "icl::right(L0_1D) = " << static_cast<int>(icl::right(L0_1D.bounds()).bits()) << endl;
- BOOST_CHECK_EQUAL(itl::right_bounds(L0_1D, L0_1T), interval_bounds::left_open());
+ BOOST_CHECK_EQUAL(icl::right_bounds(L0_1D, L0_1T), interval_bounds::left_open());
}
BOOST_AUTO_TEST_CASE(casual)
@@ -233,28 +233,28 @@
typedef interval_set<T> IntervalSetT;
typedef IntervalMapT::interval_type IntervalT;
- BOOST_CHECK_EQUAL((is_key_container_of< int , itl::map<int,int> >::value), false);
- BOOST_CHECK_EQUAL((is_key_container_of<std::pair<int,int> , itl::map<int,int> >::value), false);
- BOOST_CHECK_EQUAL((is_key_container_of<itl::set<int>, itl::set<int> >::value), true);
- BOOST_CHECK_EQUAL((is_key_container_of<itl::set<int>, itl::map<int,int> >::value), true);
- BOOST_CHECK_EQUAL((is_key_container_of<itl::map<int,int>, itl::map<int,int> >::value), true);
+ BOOST_CHECK_EQUAL((is_key_container_of< int , icl::map<int,int> >::value), false);
+ BOOST_CHECK_EQUAL((is_key_container_of<std::pair<int,int> , icl::map<int,int> >::value), false);
+ BOOST_CHECK_EQUAL((is_key_container_of<icl::set<int>, icl::set<int> >::value), true);
+ BOOST_CHECK_EQUAL((is_key_container_of<icl::set<int>, icl::map<int,int> >::value), true);
+ BOOST_CHECK_EQUAL((is_key_container_of<icl::map<int,int>, icl::map<int,int> >::value), true);
- //BOOST_CHECK_EQUAL((is_element_container<itl::map<int,int> >::value), true);
+ //BOOST_CHECK_EQUAL((is_element_container<icl::map<int,int> >::value), true);
- typedef itl::map<int,int> MapII;
+ typedef icl::map<int,int> MapII;
- //const bool xx = is_same< typename itl::map<int,int>::codomain_type,
- // typename codomain_type_of<itl::map<int,int> >::type >::value;
+ //const bool xx = is_same< typename icl::map<int,int>::codomain_type,
+ // typename codomain_type_of<icl::map<int,int> >::type >::value;
BOOST_CHECK_EQUAL(has_codomain_type<MapII>::value, true);
BOOST_CHECK_EQUAL((is_same<MapII::codomain_type, int>::value), true);
BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII,true>::type, int>::value), true);
BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII,false>::type, int>::value), false);
- BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII,false>::type, itl::no_type>::value), true);
+ BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII,false>::type, icl::no_type>::value), true);
BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII, has_codomain_type<MapII>::value >::type, int>::value), true);
- BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII, has_codomain_type<MapII>::value >::type, itl::no_type>::value), false);
+ BOOST_CHECK_EQUAL((is_same<get_codomain_type<MapII, has_codomain_type<MapII>::value >::type, icl::no_type>::value), false);
BOOST_CHECK_EQUAL((is_map<MapII>::value), true);
BOOST_CHECK_EQUAL((is_icl_container<MapII>::value), true);
@@ -285,59 +285,59 @@
BOOST_CHECK_EQUAL( is_interval_set<std::set<int> >::value, false );
#if defined(ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS) && !defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_DEFAULT)
- BOOST_CHECK( (is_same<itl::interval<int >::type, right_open_interval<int > >::value) );
- BOOST_CHECK( (is_same<itl::interval<double>::type, right_open_interval<double> >::value) );
+ BOOST_CHECK( (is_same<icl::interval<int >::type, right_open_interval<int > >::value) );
+ BOOST_CHECK( (is_same<icl::interval<double>::type, right_open_interval<double> >::value) );
- BOOST_CHECK_EQUAL( itl::interval<int>::open(0,2), itl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::left_open(0,1), itl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::right_open(1,2), itl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::closed(1,1), itl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::open(0,2), icl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::left_open(0,1), icl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::right_open(1,2), icl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::closed(1,1), icl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<float>::right_open(1.0,2.0), itl::construct<right_open_interval<float> >(1.0,2.0) );
+ BOOST_CHECK_EQUAL( icl::interval<float>::right_open(1.0,2.0), icl::construct<right_open_interval<float> >(1.0,2.0) );
//The next yields compiletime error: STATIC_ASSERTION_FAILURE
- //BOOST_CHECK_EQUAL( itl::interval<float>::left_open(1.0,2.0), itl::construct<right_open_interval<float> >(1.0,2.0) );
+ //BOOST_CHECK_EQUAL( icl::interval<float>::left_open(1.0,2.0), icl::construct<right_open_interval<float> >(1.0,2.0) );
#endif
#if defined(ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS) && defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_DEFAULT)
# if defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS) && (BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS == 0)
cout << "discrete_interval == open_interval\n";
- BOOST_CHECK( (is_same<itl::interval<int>::type, open_interval<int> >::value) );
- BOOST_CHECK_EQUAL( itl::interval<int>::open(0,2), itl::construct<open_interval<int> >(0,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::left_open(0,1), itl::construct<open_interval<int> >(0,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::right_open(1,2), itl::construct<open_interval<int> >(0,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::closed(1,1), itl::construct<open_interval<int> >(0,2) );
+ BOOST_CHECK( (is_same<icl::interval<int>::type, open_interval<int> >::value) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::open(0,2), icl::construct<open_interval<int> >(0,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::left_open(0,1), icl::construct<open_interval<int> >(0,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::right_open(1,2), icl::construct<open_interval<int> >(0,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::closed(1,1), icl::construct<open_interval<int> >(0,2) );
# elif defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS) && (BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS == 1)
cout << "discrete_interval == left_open_interval\n";
- BOOST_CHECK( (is_same<itl::interval<int>::type, left_open_interval<int> >::value) );
- BOOST_CHECK_EQUAL( itl::interval<int>::open(0,2), itl::construct<left_open_interval<int> >(0,1) );
- BOOST_CHECK_EQUAL( itl::interval<int>::left_open(0,1), itl::construct<left_open_interval<int> >(0,1) );
- BOOST_CHECK_EQUAL( itl::interval<int>::right_open(1,2), itl::construct<left_open_interval<int> >(0,1) );
- BOOST_CHECK_EQUAL( itl::interval<int>::closed(1,1), itl::construct<left_open_interval<int> >(0,1) );
+ BOOST_CHECK( (is_same<icl::interval<int>::type, left_open_interval<int> >::value) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::open(0,2), icl::construct<left_open_interval<int> >(0,1) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::left_open(0,1), icl::construct<left_open_interval<int> >(0,1) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::right_open(1,2), icl::construct<left_open_interval<int> >(0,1) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::closed(1,1), icl::construct<left_open_interval<int> >(0,1) );
# elif defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS) && (BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS == 2)
cout << "discrete_interval == right_open_interval\n";
- BOOST_CHECK( (is_same<itl::interval<int>::type, right_open_interval<int> >::value) );
- BOOST_CHECK_EQUAL( itl::interval<int>::open(0,2), itl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::left_open(0,1), itl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::right_open(1,2), itl::construct<right_open_interval<int> >(1,2) );
- BOOST_CHECK_EQUAL( itl::interval<int>::closed(1,1), itl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK( (is_same<icl::interval<int>::type, right_open_interval<int> >::value) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::open(0,2), icl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::left_open(0,1), icl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::right_open(1,2), icl::construct<right_open_interval<int> >(1,2) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::closed(1,1), icl::construct<right_open_interval<int> >(1,2) );
# elif defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS) && (BOOST_ICL_DISCRETE_STATIC_INTERVAL_BORDERS == 3)
cout << "discrete_interval == closed_interval\n";
- BOOST_CHECK( (is_same<itl::interval<int>::type, closed_interval<int> >::value) );
- BOOST_CHECK_EQUAL( itl::interval<int>::open(0,2), itl::construct<closed_interval<int> >(1,1) );
- BOOST_CHECK_EQUAL( itl::interval<int>::left_open(0,1), itl::construct<closed_interval<int> >(1,1) );
- BOOST_CHECK_EQUAL( itl::interval<int>::right_open(1,2), itl::construct<closed_interval<int> >(1,1) );
- BOOST_CHECK_EQUAL( itl::interval<int>::closed(1,1), itl::construct<closed_interval<int> >(1,1) );
+ BOOST_CHECK( (is_same<icl::interval<int>::type, closed_interval<int> >::value) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::open(0,2), icl::construct<closed_interval<int> >(1,1) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::left_open(0,1), icl::construct<closed_interval<int> >(1,1) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::right_open(1,2), icl::construct<closed_interval<int> >(1,1) );
+ BOOST_CHECK_EQUAL( icl::interval<int>::closed(1,1), icl::construct<closed_interval<int> >(1,1) );
# else
cout << "#else part, INTERVAL_BORDERS not in {0,1,2,3}\n";
#endif //defined(ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS) && defined(BOOST_ICL_DISCRETE_STATIC_INTERVAL_DEFAULT)
#else
- BOOST_CHECK( (is_same<itl::interval<int >::type, discrete_interval<int > >::value) );
- BOOST_CHECK( (is_same<itl::interval<double>::type, continuous_interval<double> >::value) );
+ BOOST_CHECK( (is_same<icl::interval<int >::type, discrete_interval<int > >::value) );
+ BOOST_CHECK( (is_same<icl::interval<double>::type, continuous_interval<double> >::value) );
#endif
}
Modified: sandbox/itl/libs/itl/test/test_combinable_/test_combinable.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_combinable_/test_combinable.cpp (original)
+++ sandbox/itl/libs/itl/test/test_combinable_/test_combinable.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::casual unit test
+#define BOOST_TEST_MODULE icl::casual unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -25,7 +25,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
template<template<class, class>class IsCombinable,
Modified: sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_continuous_interval_/test_continuous_interval.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval unit test
+#define BOOST_TEST_MODULE icl::interval unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_itl_interval_shared.hpp"
Modified: sandbox/itl/libs/itl/test/test_functions.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_functions.hpp (original)
+++ sandbox/itl/libs/itl/test/test_functions.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,15 +19,15 @@
#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/functors.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class T, class U, class Trt,
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, T),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -45,8 +45,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -64,7 +64,7 @@
BOOST_CHECK_EQUAL( looped_copied_map, std_copied_map );
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_TEST_FUNCTIONS_H_JOFA_091003
Modified: sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,13 +11,13 @@
template <class T, class IntervalT>
void interval_ctor_4_ordered_types()
{
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(icl::is_empty(IntervalT()), true);
+ BOOST_CHECK_EQUAL(icl::cardinality(IntervalT()), icl::identity_element<typename icl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(icl::size(IntervalT()), icl::identity_element<typename icl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL( IntervalT(), IntervalT() );
BOOST_CHECK_EQUAL( IntervalT(), IntervalT(IntervalT().lower(), IntervalT().upper()) );
- BOOST_CHECK_EQUAL( IntervalT(), IntervalT(itl::lower(IntervalT()), itl::upper(IntervalT())) );
+ BOOST_CHECK_EQUAL( IntervalT(), IntervalT(icl::lower(IntervalT()), icl::upper(IntervalT())) );
}
@@ -26,7 +26,7 @@
{
typedef right_open_interval<T,Compare> L__D; // L__D for [..)
typedef left_open_interval<T,Compare> C__I; // C__I for (..]
- typedef typename itl::interval<T,Compare>::type IntervalT;
+ typedef typename icl::interval<T,Compare>::type IntervalT;
BOOST_CHECK( is_interval<L__D>::value );
BOOST_CHECK( has_difference<typename interval_traits<L__D>::domain_type>::value );
Modified: sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_discrete_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -26,7 +26,7 @@
void discrete_interval_ctor__dis_4_dyn_v_sta() // discrete && (dynamic or static)
{
BOOST_CHECK_EQUAL( IntervalT(MK_v(3)), IntervalT(MK_v(3)) );
- BOOST_CHECK_EQUAL( itl::contains(IntervalT(MK_v(1)), MK_v(1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalT(MK_v(1)), MK_v(1)), true );
}
template <class T, ITL_COMPARE Compare>
@@ -36,7 +36,7 @@
typedef left_open_interval<T,Compare> C__I; // C__I for (..]
typedef closed_interval<T,Compare> L__I; // L__I for [..]
typedef open_interval<T,Compare> C__D; // C__D for (..)
- typedef typename itl::interval<T,Compare>::type IntervalT;
+ typedef typename icl::interval<T,Compare>::type IntervalT;
BOOST_CHECK( is_interval<L__D>::value );
BOOST_CHECK( has_difference<typename interval_traits<L__D>::domain_type>::value );
Modified: sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,25 +13,25 @@
{
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
- BOOST_CHECK_EQUAL(IntervalT().lower(), itl::identity_element<T>::value());
- BOOST_CHECK_EQUAL(IntervalT().upper(), itl::identity_element<T>::value());
- BOOST_CHECK_EQUAL(itl::lower(IntervalT()), itl::identity_element<T>::value());
- BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::identity_element<T>::value());
-
- IntervalT itv = IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value());
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value()));
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value(), interval_bounds::right_open()));
+ BOOST_CHECK_EQUAL(IntervalT().lower(), icl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), icl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(icl::lower(IntervalT()), icl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(icl::upper(IntervalT()), icl::identity_element<T>::value());
+
+ IntervalT itv = IntervalT(icl::identity_element<T>::value(), icl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(icl::identity_element<T>::value(), icl::identity_element<T>::value()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(icl::identity_element<T>::value(), icl::identity_element<T>::value(), interval_bounds::right_open()));
}
template <class T>
void dynamic_interval_bounds_4_bicremental_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
BOOST_CHECK_EQUAL( T(), pred(succ(T())));
- BOOST_CHECK_EQUAL( itl::identity_element<T>::value(), pred(succ(itl::identity_element<T>::value())) );
- BOOST_CHECK_EQUAL( itl::unit_element<T>::value(), succ(itl::identity_element<T>::value()) );
- BOOST_CHECK_EQUAL( length(IntervalT()), itl::identity_element<typename difference_type_of<T>::type>::value() );
+ BOOST_CHECK_EQUAL( icl::identity_element<T>::value(), pred(succ(icl::identity_element<T>::value())) );
+ BOOST_CHECK_EQUAL( icl::unit_element<T>::value(), succ(icl::identity_element<T>::value()) );
+ BOOST_CHECK_EQUAL( length(IntervalT()), icl::identity_element<typename difference_type_of<T>::type>::value() );
//LAW: I x: borders(x)==closed => contains(x, lower(x)) && contains(x, upper(x))
check_border_containedness(I_I(0,0));
@@ -51,12 +51,12 @@
template <class T>
void discrete_dynamic_interval_bounds_4_bicremental_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
- BOOST_CHECK( itl::bounds(I_I(2,4)) == interval_bounds::closed() );
- BOOST_CHECK( itl::bounds(I_D(2,5)) == interval_bounds::right_open() );
- BOOST_CHECK( itl::bounds(C_I(1,4)) == interval_bounds::left_open() );
- BOOST_CHECK( itl::bounds(C_D(1,5)) == interval_bounds::open() );
+ BOOST_CHECK( icl::bounds(I_I(2,4)) == interval_bounds::closed() );
+ BOOST_CHECK( icl::bounds(I_D(2,5)) == interval_bounds::right_open() );
+ BOOST_CHECK( icl::bounds(C_I(1,4)) == interval_bounds::left_open() );
+ BOOST_CHECK( icl::bounds(C_D(1,5)) == interval_bounds::open() );
}
Modified: sandbox/itl/libs/itl/test/test_icl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,29 +18,29 @@
void interval_ctor_4_ordered_types()
{
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
- typedef typename itl::size_type_of<T>::type SizeT;
- T t_0 = itl::identity_element<T>::value();
- T t_1 = itl::unit_element<T>::value();
- SizeT s_0 = itl::identity_element<SizeT>::value();
- SizeT s_1 = itl::unit_element<SizeT>::value();
+ typedef typename icl::size_type_of<T>::type SizeT;
+ T t_0 = icl::identity_element<T>::value();
+ T t_1 = icl::unit_element<T>::value();
+ SizeT s_0 = icl::identity_element<SizeT>::value();
+ SizeT s_1 = icl::unit_element<SizeT>::value();
// Default ctor and emptieness
- BOOST_CHECK_EQUAL( itl::is_empty(IntervalT()), true );
- BOOST_CHECK_EQUAL( itl::cardinality(IntervalT()), s_0 );
- BOOST_CHECK_EQUAL( itl::size(IntervalT()), s_0 );
+ BOOST_CHECK_EQUAL( icl::is_empty(IntervalT()), true );
+ BOOST_CHECK_EQUAL( icl::cardinality(IntervalT()), s_0 );
+ BOOST_CHECK_EQUAL( icl::size(IntervalT()), s_0 );
BOOST_CHECK_EQUAL( IntervalT(), IntervalT() );
BOOST_CHECK_EQUAL( IntervalT(), IntervalT(IntervalT().lower(), IntervalT().upper()) );
- BOOST_CHECK_EQUAL( IntervalT(), IntervalT(itl::lower(IntervalT()), itl::upper(IntervalT())) );
+ BOOST_CHECK_EQUAL( IntervalT(), IntervalT(icl::lower(IntervalT()), icl::upper(IntervalT())) );
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT(t_0, t_1)) >= s_1, true);
- BOOST_CHECK_EQUAL(( itl::contains(IntervalT(t_0, t_1), t_0)
- || itl::contains(IntervalT(t_0, t_1), t_1)), true);
+ BOOST_CHECK_EQUAL(icl::cardinality(IntervalT(t_0, t_1)) >= s_1, true);
+ BOOST_CHECK_EQUAL(( icl::contains(IntervalT(t_0, t_1), t_0)
+ || icl::contains(IntervalT(t_0, t_1), t_1)), true);
BOOST_CHECK_EQUAL(IntervalT(t_0, t_1).lower(), t_0);
BOOST_CHECK_EQUAL(IntervalT(t_0, t_1).upper(), t_1);
- BOOST_CHECK_EQUAL(lower(itl::construct<IntervalT>(t_0, t_1)), t_0);
- BOOST_CHECK_EQUAL(upper(itl::construct<IntervalT>(t_0, t_1)), t_1);
+ BOOST_CHECK_EQUAL(lower(icl::construct<IntervalT>(t_0, t_1)), t_0);
+ BOOST_CHECK_EQUAL(upper(icl::construct<IntervalT>(t_0, t_1)), t_1);
}
@@ -52,40 +52,40 @@
// LAW: This law applies to all discrete and to dynamic continuous intervals
// LAW: No singletons can be constructed for static continuous right_open and left_open intervals
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
- typedef typename itl::size_type_of<T>::type SizeT;
- T t_0 = itl::identity_element<T>::value();
- T t_1 = itl::unit_element<T>::value();
- SizeT s_1 = itl::unit_element<SizeT>::value();
+ typedef typename icl::size_type_of<T>::type SizeT;
+ T t_0 = icl::identity_element<T>::value();
+ T t_1 = icl::unit_element<T>::value();
+ SizeT s_1 = icl::unit_element<SizeT>::value();
#ifdef BOOST_MSVC
BOOST_CHECK_EQUAL( is_singelizable<IntervalT>::value, true );
#endif
- BOOST_CHECK_EQUAL( itl::cardinality(itl::singleton<IntervalT>(t_0)), s_1 );
- BOOST_CHECK_EQUAL( itl::size(itl::singleton<IntervalT>(t_0)), s_1 );
- BOOST_CHECK_EQUAL( itl::cardinality(itl::singleton<IntervalT>(t_1)), s_1 );
- BOOST_CHECK_EQUAL( itl::size(itl::singleton<IntervalT>(t_1)), s_1 );
+ BOOST_CHECK_EQUAL( icl::cardinality(icl::singleton<IntervalT>(t_0)), s_1 );
+ BOOST_CHECK_EQUAL( icl::size(icl::singleton<IntervalT>(t_0)), s_1 );
+ BOOST_CHECK_EQUAL( icl::cardinality(icl::singleton<IntervalT>(t_1)), s_1 );
+ BOOST_CHECK_EQUAL( icl::size(icl::singleton<IntervalT>(t_1)), s_1 );
- BOOST_CHECK_EQUAL( itl::contains(itl::singleton<IntervalT>(t_0), t_0), true );
- BOOST_CHECK_EQUAL( itl::contains(itl::singleton<IntervalT>(t_1), t_1), true );
+ BOOST_CHECK_EQUAL( icl::contains(icl::singleton<IntervalT>(t_0), t_0), true );
+ BOOST_CHECK_EQUAL( icl::contains(icl::singleton<IntervalT>(t_1), t_1), true );
}
template <class IntervalT>
void singelizable_interval_4_bicremental_types()
{
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
- typedef typename itl::size_type_of<T>::type SizeT;
- //T t_0 = itl::identity_element<T>::value();
- SizeT s_1 = itl::unit_element<SizeT>::value();
+ typedef typename icl::size_type_of<T>::type SizeT;
+ //T t_0 = icl::identity_element<T>::value();
+ SizeT s_1 = icl::unit_element<SizeT>::value();
#ifdef BOOST_MSVC
BOOST_CHECK_EQUAL( is_singelizable<IntervalT>::value, true );
#endif
- BOOST_CHECK_EQUAL( itl::cardinality(IntervalT(MK_v(3))), s_1 );
- BOOST_CHECK_EQUAL( itl::size(IntervalT(MK_v(4))), s_1 );
- BOOST_CHECK_EQUAL( itl::singleton<IntervalT>(MK_v(2)), itl::singleton<IntervalT>(MK_v(2)) );
- BOOST_CHECK_EQUAL( itl::contains(IntervalT(MK_v(1)), MK_v(1)), true );
+ BOOST_CHECK_EQUAL( icl::cardinality(IntervalT(MK_v(3))), s_1 );
+ BOOST_CHECK_EQUAL( icl::size(IntervalT(MK_v(4))), s_1 );
+ BOOST_CHECK_EQUAL( icl::singleton<IntervalT>(MK_v(2)), icl::singleton<IntervalT>(MK_v(2)) );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalT(MK_v(1)), MK_v(1)), true );
}
Modified: sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,22 +13,22 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
void make_3_icl_maps_and_derivatives_1
- (itl::map<T,U,Trt>& map_a,
- itl::map<T,U,Trt>& map_b,
- itl::map<T,U,Trt>& map_c,
+ (icl::map<T,U,Trt>& map_a,
+ icl::map<T,U,Trt>& map_b,
+ icl::map<T,U,Trt>& map_c,
std::pair<T,U>& map_pair_a,
std::pair<T,U>& map_pair_b,
IntervalMap<T,U,Trt>*)
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
map_pair_a = sK_v(5,1);
map_pair_b = sK_v(9,1);
@@ -70,8 +70,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -79,7 +79,7 @@
void icl_quantifier_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -94,8 +94,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -103,7 +103,7 @@
void icl_quantifier_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -121,8 +121,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -130,7 +130,7 @@
void icl_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -145,8 +145,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -154,7 +154,7 @@
void icl_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -172,8 +172,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -181,7 +181,7 @@
void icl_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -198,8 +198,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -207,7 +207,7 @@
void icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -228,8 +228,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -237,7 +237,7 @@
void icl_quantifier_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -254,8 +254,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -266,7 +266,7 @@
// (1) (IntervalMapT, +) is an abelian group and
// (2) The inverability law: (0 - x) + x =p= 0 holds.
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
@@ -286,8 +286,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -295,7 +295,7 @@
void icl_quantifier_check_containedness_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT aux;
MapT map_a, map_b, map_c;
std::pair<T,U> map_pair_a, map_pair_b;
Modified: sandbox/itl/libs/itl/test/test_icl_static_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_static_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_static_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,13 +11,13 @@
template <class T, class IntervalT>
void static_interval_ctor_4_ordered_types()
{
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(icl::is_empty(IntervalT()), true);
+ BOOST_CHECK_EQUAL(icl::cardinality(IntervalT()), icl::identity_element<typename icl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(icl::size(IntervalT()), icl::identity_element<typename icl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL( IntervalT(), IntervalT() );
BOOST_CHECK_EQUAL( IntervalT(), IntervalT(IntervalT().lower(), IntervalT().upper()) );
- BOOST_CHECK_EQUAL( IntervalT(), IntervalT(itl::lower(IntervalT()), itl::upper(IntervalT())) );
+ BOOST_CHECK_EQUAL( IntervalT(), IntervalT(icl::lower(IntervalT()), icl::upper(IntervalT())) );
}
Modified: sandbox/itl/libs/itl/test/test_interval_laws.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_laws.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_laws.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,7 +20,7 @@
#include <boost/itl/type_traits/is_interval.hpp>
#include <boost/itl/concept/interval.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
template<class Type>
@@ -28,49 +28,49 @@
check_border_containedness(const Type& itv)
{
typedef typename interval_traits<Type>::domain_type domain_type;
- domain_type lo = itl::lower(itv);
- domain_type up = itl::upper(itv);
+ domain_type lo = icl::lower(itv);
+ domain_type up = icl::upper(itv);
//LAW: The empty set is contained in every set
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::identity_element<Type>::value()), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::identity_element<Type>::value()), true);
//LAW: Reflexivity: Every interval contains itself
- BOOST_CHECK_EQUAL(itl::contains(itv, itv), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, itv), true);
- if(itl::bounds(itv) == interval_bounds::closed())
+ if(icl::bounds(itv) == interval_bounds::closed())
{
- BOOST_CHECK_EQUAL(itl::contains(itv, lo), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, up), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: closed(lo,up)), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>::right_open(lo,up)), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: left_open(lo,up)), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, lo), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, up), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: closed(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>::right_open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: left_open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: open(lo,up)), true);
}
- else if(itl::bounds(itv) == interval_bounds::right_open())
+ else if(icl::bounds(itv) == interval_bounds::right_open())
{
- BOOST_CHECK_EQUAL(itl::contains(itv, lo), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, up), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: closed(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>::right_open(lo,up)), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: left_open(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, lo), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, up), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: closed(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>::right_open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: left_open(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: open(lo,up)), true);
}
- else if(itl::bounds(itv) == interval_bounds::left_open())
+ else if(icl::bounds(itv) == interval_bounds::left_open())
{
- BOOST_CHECK_EQUAL(itl::contains(itv, lo), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, up), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: closed(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>::right_open(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: left_open(lo,up)), true);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, lo), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, up), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: closed(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>::right_open(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: left_open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: open(lo,up)), true);
}
- else if(itl::bounds(itv) == interval_bounds::open())
+ else if(icl::bounds(itv) == interval_bounds::open())
{
- BOOST_CHECK_EQUAL(itl::contains(itv, lo), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, up), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: closed(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>::right_open(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: left_open(lo,up)), false);
- BOOST_CHECK_EQUAL(itl::contains(itv, itl::interval<domain_type>:: open(lo,up)), true);
+ BOOST_CHECK_EQUAL(icl::contains(itv, lo), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, up), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: closed(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>::right_open(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: left_open(lo,up)), false);
+ BOOST_CHECK_EQUAL(icl::contains(itv, icl::interval<domain_type>:: open(lo,up)), true);
}
else
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map unit test
+#define BOOST_TEST_MODULE icl::interval_map unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_map_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_interval_map_infix_/test_interval_map_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_infix_/test_interval_map_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_infix_/test_interval_map_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_infix unit test
+#define BOOST_TEST_MODULE icl::interval_map_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_map_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_interval_map_infix_mixed_/test_interval_map_infix_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_infix_mixed_/test_interval_map_infix_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_infix_mixed_/test_interval_map_infix_mixed.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_infix_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_map_infix_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_map_mixed_infix_plus_overload_4_bicremental_types, T, bicremental_types)
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -228,9 +228,9 @@
split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
join_map = split_map;
- itl::domain(split_set, split_map);
- itl::domain(sep_set, split_map);
- itl::domain(join_set, split_map);
+ icl::domain(split_set, split_map);
+ icl::domain(sep_set, split_map);
+ icl::domain(join_set, split_map);
iterative_size(split_map);
BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
@@ -265,20 +265,20 @@
// ->2 ->1 ->1 ->2
split_interval_map<T,U,Trt> split_sub_map1 = split_map;
split_sub_map1.erase(MK_v(2));
- BOOST_CHECK_EQUAL( itl::contains(split_sub_map1, MK_v(2)), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_sub_map1, MK_v(2)), false );
interval_map<T,U,Trt> join_sub_map2;
join_sub_map2 = split_map;
join_sub_map2.erase(MK_v(1));
- BOOST_CHECK_EQUAL( itl::contains(join_sub_map2, MK_v(1)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_sub_map2, MK_v(1)), false );
split_interval_set<T> split_sub_set1;
separate_interval_set<T> sep_sub_set1;
interval_set<T> join_sub_set1;
- itl::domain(split_sub_set1, split_sub_map1);
- itl::domain(sep_sub_set1, split_sub_map1);
- itl::domain(join_sub_set1, split_sub_map1);
+ icl::domain(split_sub_set1, split_sub_map1);
+ icl::domain(sep_sub_set1, split_sub_map1);
+ icl::domain(join_sub_set1, split_sub_map1);
BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, split_map), inclusion::subset );
BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, split_map), inclusion::subset );
@@ -349,9 +349,9 @@
split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
join_map = split_map;
- itl::domain(split_set, split_map);
- itl::domain(sep_set, split_map);
- itl::domain(join_set, split_map);
+ icl::domain(split_set, split_map);
+ icl::domain(sep_set, split_map);
+ icl::domain(join_set, split_map);
BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
@@ -360,35 +360,35 @@
BOOST_CHECK_EQUAL( iterative_size(join_set), 2 );
// Key types
- BOOST_CHECK_EQUAL( itl::contains(split_map, MK_v(0)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, MK_v(5)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, MK_v(9)), true );
-
- BOOST_CHECK_EQUAL( itl::contains(split_map, I_D(2,3)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, I_D(0,6)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, I_D(0,7)), false );
- BOOST_CHECK_EQUAL( itl::contains(join_map, I_D(2,3)), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, I_D(0,6)), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, I_D(0,7)), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, MK_v(0)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, MK_v(5)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, MK_v(9)), true );
+
+ BOOST_CHECK_EQUAL( icl::contains(split_map, I_D(2,3)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, I_D(0,6)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, I_D(0,7)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, I_D(2,3)), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, I_D(0,6)), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, I_D(0,7)), false );
// Map types
- BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(1,2)), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(5,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(9,2)), true );
-
- BOOST_CHECK_EQUAL( itl::contains(split_map, IDv(2,6,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, IDv(1,6,1)), false );
- BOOST_CHECK_EQUAL( itl::contains(split_map, IIv(8,9,2)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, IIv(8,9,3)), false );
- BOOST_CHECK_EQUAL( itl::contains(join_map, IDv(2,6,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, IDv(1,6,1)), false );
- BOOST_CHECK_EQUAL( itl::contains(join_map, IIv(8,9,2)), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, IIv(8,9,3)), false );
-
- BOOST_CHECK_EQUAL( itl::contains(split_map, join_map), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, split_map), true );
- BOOST_CHECK_EQUAL( itl::within(split_map, join_map), true );
- BOOST_CHECK_EQUAL( itl::within(join_map, split_map), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, K_v(1,2)), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, K_v(5,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, K_v(9,2)), true );
+
+ BOOST_CHECK_EQUAL( icl::contains(split_map, IDv(2,6,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, IDv(1,6,1)), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, IIv(8,9,2)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, IIv(8,9,3)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, IDv(2,6,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, IDv(1,6,1)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, IIv(8,9,2)), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, IIv(8,9,3)), false );
+
+ BOOST_CHECK_EQUAL( icl::contains(split_map, join_map), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, split_map), true );
+ BOOST_CHECK_EQUAL( icl::within(split_map, join_map), true );
+ BOOST_CHECK_EQUAL( icl::within(join_map, split_map), true );
//--------------------------------------------------------------------------
// inclusions
@@ -399,37 +399,37 @@
// ->2 ->1 ->1 ->2
split_interval_map<T,U,Trt> split_sub_map1 = split_map;
split_sub_map1.erase(MK_v(2));
- BOOST_CHECK_EQUAL( itl::contains(split_sub_map1, MK_v(2)), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_sub_map1, MK_v(2)), false );
interval_map<T,U,Trt> join_sub_map2;
join_sub_map2 = split_map;
join_sub_map2.erase(MK_v(1));
- BOOST_CHECK_EQUAL( itl::contains(join_sub_map2, MK_v(1)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_sub_map2, MK_v(1)), false );
split_interval_set<T> split_sub_set1;
separate_interval_set<T> sep_sub_set1;
interval_set<T> join_sub_set1;
- itl::domain(split_sub_set1, split_sub_map1);
- itl::domain(sep_sub_set1, split_sub_map1);
- itl::domain(join_sub_set1, split_sub_map1);
-
- BOOST_CHECK_EQUAL( itl::within(split_sub_map1, split_map), true );
- BOOST_CHECK_EQUAL( itl::within(join_sub_map2, split_map), true );
- BOOST_CHECK_EQUAL( itl::within(split_sub_map1, join_map ), true );
- BOOST_CHECK_EQUAL( itl::within(join_sub_map2, join_map ), true );
-
- BOOST_CHECK_EQUAL( itl::contains(split_map, split_sub_map1), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, join_sub_map2), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, split_sub_map1), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, join_sub_map2), true );
-
- BOOST_CHECK_EQUAL( itl::contains(split_map, split_sub_set1), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, sep_sub_set1), true );
- BOOST_CHECK_EQUAL( itl::contains(split_map, join_sub_set1), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, split_sub_set1), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, sep_sub_set1), true );
- BOOST_CHECK_EQUAL( itl::contains(join_map, join_sub_set1), true );
+ icl::domain(split_sub_set1, split_sub_map1);
+ icl::domain(sep_sub_set1, split_sub_map1);
+ icl::domain(join_sub_set1, split_sub_map1);
+
+ BOOST_CHECK_EQUAL( icl::within(split_sub_map1, split_map), true );
+ BOOST_CHECK_EQUAL( icl::within(join_sub_map2, split_map), true );
+ BOOST_CHECK_EQUAL( icl::within(split_sub_map1, join_map ), true );
+ BOOST_CHECK_EQUAL( icl::within(join_sub_map2, join_map ), true );
+
+ BOOST_CHECK_EQUAL( icl::contains(split_map, split_sub_map1), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, join_sub_map2), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, split_sub_map1), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, join_sub_map2), true );
+
+ BOOST_CHECK_EQUAL( icl::contains(split_map, split_sub_set1), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, sep_sub_set1), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, join_sub_set1), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, split_sub_set1), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, sep_sub_set1), true );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, join_sub_set1), true );
split_interval_map<T,U,Trt> split_unrel_map11 = split_sub_map1;
split_unrel_map11.set(CIv(7,9,1));
@@ -439,20 +439,20 @@
join_unrel_map21.set(K_v(0,1));
BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
- BOOST_CHECK_EQUAL( itl::contains(split_unrel_map11, split_map), false );
- BOOST_CHECK_EQUAL( itl::contains(join_unrel_map21, split_map), false );
- BOOST_CHECK_EQUAL( itl::contains(split_unrel_map11, join_map), false );
- BOOST_CHECK_EQUAL( itl::contains(join_unrel_map21, join_map), false );
-
- BOOST_CHECK_EQUAL( itl::within(split_unrel_map11, split_map), false );
- BOOST_CHECK_EQUAL( itl::within(join_unrel_map21, split_map), false );
- BOOST_CHECK_EQUAL( itl::within(split_unrel_map11, join_map), false );
- BOOST_CHECK_EQUAL( itl::within(join_unrel_map21, join_map), false );
-
- BOOST_CHECK_EQUAL( itl::contains(split_map, split_unrel_map11), false );
- BOOST_CHECK_EQUAL( itl::contains(split_map, join_unrel_map21), false );
- BOOST_CHECK_EQUAL( itl::contains(join_map, split_unrel_map11), false );
- BOOST_CHECK_EQUAL( itl::contains(join_map, join_unrel_map21), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_unrel_map11, split_map), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_unrel_map21, split_map), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_unrel_map11, join_map), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_unrel_map21, join_map), false );
+
+ BOOST_CHECK_EQUAL( icl::within(split_unrel_map11, split_map), false );
+ BOOST_CHECK_EQUAL( icl::within(join_unrel_map21, split_map), false );
+ BOOST_CHECK_EQUAL( icl::within(split_unrel_map11, join_map), false );
+ BOOST_CHECK_EQUAL( icl::within(join_unrel_map21, join_map), false );
+
+ BOOST_CHECK_EQUAL( icl::contains(split_map, split_unrel_map11), false );
+ BOOST_CHECK_EQUAL( icl::contains(split_map, join_unrel_map21), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, split_unrel_map11), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_map, join_unrel_map21), false );
}
@@ -969,10 +969,10 @@
join_A.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1);
join_B.insert(I7_8D_1).insert(I8_9I_1);
- itl::domain(split_dA, split_A);
- itl::domain(split_dB, split_B);
- itl::domain(join_dA, join_A);
- itl::domain(join_dB, join_B);
+ icl::domain(split_dA, split_A);
+ icl::domain(split_dB, split_B);
+ icl::domain(join_dA, join_A);
+ icl::domain(join_dB, join_B);
//-------------------------------------------------------------------------
insert(split_X, split_A);
@@ -1444,11 +1444,11 @@
}
template<class Type>
-struct size_greater_1 : public itl::property<Type>
+struct size_greater_1 : public icl::property<Type>
{
bool operator()(const Type& value)const
{
- return itl::size(value.first) > 1 ;
+ return icl::size(value.first) > 1 ;
}
};
@@ -1491,7 +1491,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);
- itl::erase_if(size_greater_1<typename SplitIntervalMapT::value_type>(), split_A);
+ icl::erase_if(size_greater_1<typename SplitIntervalMapT::value_type>(), split_A);
BOOST_CHECK_EQUAL( split_A, split_B );
}
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed2_/test_interval_map_mixed2.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed2_/test_interval_map_mixed2.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed2_/test_interval_map_mixed2.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_map_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_map_mixed.hpp"
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_map_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_map_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_map_mixed.hpp"
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,8 +11,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -42,10 +42,10 @@
//empty set
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalMapT().empty(), true);
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalMapT()), true);
+ BOOST_CHECK_EQUAL(icl::is_empty(IntervalMapT()), true);
BOOST_CHECK_EQUAL(cardinality(IntervalMapT()), identity_element<size_T>::value());
BOOST_CHECK_EQUAL(IntervalMapT().size(), identity_element<size_T>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalMapT()), identity_element<size_T>::value());
+ BOOST_CHECK_EQUAL(icl::size(IntervalMapT()), identity_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(IntervalMapT()), 0);
BOOST_CHECK_EQUAL(IntervalMapT().iterative_size(), 0);
BOOST_CHECK_EQUAL(iterative_size(IntervalMapT()), 0);
@@ -137,22 +137,22 @@
BOOST_CHECK_EQUAL(hull(single_I0_1I_u1).upper(), I0_1I.upper());
//contains predicate
- BOOST_CHECK_EQUAL(itl::contains(single_I0_0I_u1, v0), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_0I_u1, v0_u1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_0I_u1, I0_0I_u1), true);
-
- BOOST_CHECK_EQUAL(itl::contains(single_I1_1I_u1, v1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I1_1I_u1, v1_u1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I1_1I_u1, I1_1I_u1), true);
-
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, v0), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, I0_1I_u1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, v1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, I1_1I_u1), true);
-
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, single_I0_0I_u1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, single_I1_1I_u1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, single_I0_1I_u1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_0I_u1, v0), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_0I_u1, v0_u1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_0I_u1, I0_0I_u1), true);
+
+ BOOST_CHECK_EQUAL(icl::contains(single_I1_1I_u1, v1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I1_1I_u1, v1_u1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I1_1I_u1, I1_1I_u1), true);
+
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, v0), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, I0_1I_u1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, v1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, I1_1I_u1), true);
+
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, single_I0_0I_u1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, single_I1_1I_u1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, single_I0_1I_u1), true);
BOOST_CHECK_EQUAL(cardinality(single_I0_0I_u1), unit_element<size_T>::value());
BOOST_CHECK_EQUAL(single_I0_0I_u1.size(), unit_element<size_T>::value());
@@ -165,8 +165,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -230,8 +230,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -284,8 +284,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -319,8 +319,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -348,8 +348,8 @@
BOOST_CHECK_EQUAL( cardinality(is_1_3_5), s3 );
BOOST_CHECK_EQUAL( is_1_3_5.size(), s3 );
- itl::length(is_1_3_5);
- BOOST_CHECK_EQUAL( itl::length(is_1_3_5), d0 );
+ icl::length(is_1_3_5);
+ BOOST_CHECK_EQUAL( icl::length(is_1_3_5), d0 );
BOOST_CHECK_EQUAL( interval_count(is_1_3_5), 3 );
BOOST_CHECK_EQUAL( is_1_3_5.iterative_size(), 3 );
BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
@@ -364,17 +364,17 @@
is_123_5 += typename IntervalMapT::value_type(IntervalT::open(v1,v3),u1);
//USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
- BOOST_CHECK_EQUAL( cardinality(is_123_5), itl::infinity<size_T>::value() );
- BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
- BOOST_CHECK_EQUAL( itl::length(is_123_5), d2 );
+ BOOST_CHECK_EQUAL( cardinality(is_123_5), icl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( is_123_5.size(), icl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( icl::length(is_123_5), d2 );
}
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -429,8 +429,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -441,21 +441,21 @@
typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMapT::set_type IntervalSetT;
IntervalMapT itv_map; itv_map.add(K_v(3,1));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, MK_v(3)), true );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, K_v(3,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(3)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, K_v(3,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalMapT().add(K_v(3,1)), K_v(3,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalMapT().add(K_v(3,1)), MK_v(3)), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalMapT().insert(K_v(3,1)), K_v(3,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalMapT().add(K_v(3,1)), K_v(3,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalMapT().add(K_v(3,1)), MK_v(3)), true );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalMapT().insert(K_v(3,1)), K_v(3,1)), true );
itv_map.clear();
- BOOST_CHECK_EQUAL( itl::contains((itv_map += IIv(3,7,1)), IIv(3,7,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, IIv(3,7,2)), false );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(3,7)), true );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(4,6)), true );
- BOOST_CHECK_EQUAL( itl::contains((itv_map += CIv(7,9,1)),IIv(3,9,1)), true );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(4,8)), true );
- BOOST_CHECK_EQUAL( itl::contains((itv_map += IIv(11,12,1)), IIv(3,12,1)), false );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(4,11)), false );
+ BOOST_CHECK_EQUAL( icl::contains((itv_map += IIv(3,7,1)), IIv(3,7,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, IIv(3,7,2)), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(3,7)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(4,6)), true );
+ BOOST_CHECK_EQUAL( icl::contains((itv_map += CIv(7,9,1)),IIv(3,9,1)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(4,8)), true );
+ BOOST_CHECK_EQUAL( icl::contains((itv_map += IIv(11,12,1)), IIv(3,12,1)), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(4,11)), false );
IntervalMapT itv_map0 = itv_map;
@@ -463,17 +463,17 @@
IntervalMapT itv_map2(IIv(5,8,1));
itv_map2.add(K_v(9,1)).add(K_v(11,1));
itv_map += itv_map2;
- BOOST_CHECK_EQUAL( itl::contains(itv_map, itv_map2), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_map2), true );
IntervalSetT itv_set2;
- itl::domain(itv_set2, itv_map2);
- BOOST_CHECK_EQUAL( itl::contains(itv_map, itv_set2), true );
+ icl::domain(itv_set2, itv_map2);
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set2), true );
}
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -486,27 +486,27 @@
IntervalMapT itv_map;
itv_map.add(IDv(1,3,1));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, MK_v(0)), false );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, MK_v(2)), true );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, MK_v(3)), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(0)), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(2)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(3)), false );
itv_map.add(IDv(3,6,2));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(0,0)), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(0,0)), false );
contains(itv_map, I_I(2,4));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(2,4)), true );
- BOOST_CHECK_EQUAL( itl::contains(itv_map, I_I(6,6)), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(2,4)), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(6,6)), false );
itv_map.add(IDv(8,9,2));
IntervalSetT itv_set;
itv_set.add(C_I(1,2)).add(C_D(2,6)).add(I_I(8,8));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, itv_set), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), true );
itv_set.add(I_I(1,4));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, itv_set), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), true );
itv_set.add(I_I(1,4));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, itv_set), true );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), true );
itv_set.add(I_I(7,7));
- BOOST_CHECK_EQUAL( itl::contains(itv_map, itv_set), false );
+ BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), false );
}
@@ -514,8 +514,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -547,7 +547,7 @@
all -= section;
complement += all;
//complement.erase(I3_5I);
- itl::erase(complement, section);
+ icl::erase(complement, section);
BOOST_CHECK_EQUAL( disjoint(section, complement), true );
BOOST_CHECK_EQUAL( intersects(section, complement), false );
}
@@ -557,8 +557,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -664,8 +664,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -782,8 +782,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -834,8 +834,8 @@
BOOST_CHECK_EQUAL( intersects(map_A, map_B), false );
BOOST_CHECK_EQUAL( intersects(map_B, map_A), false );
- itl::domain(set_A, map_A);
- itl::domain(set_B, map_B);
+ icl::domain(set_A, map_A);
+ icl::domain(set_B, map_B);
BOOST_CHECK_EQUAL( disjoint(map_A, set_B), true );
BOOST_CHECK_EQUAL( disjoint(set_B, map_A), true );
BOOST_CHECK_EQUAL( disjoint(set_A, map_B), true );
@@ -852,8 +852,8 @@
BOOST_CHECK_EQUAL( intersects(map_A, map_B), true );
BOOST_CHECK_EQUAL( intersects(map_B, map_A), true );
- itl::domain(set_A, map_A);
- itl::domain(set_B, map_B);
+ icl::domain(set_A, map_A);
+ icl::domain(set_B, map_B);
BOOST_CHECK_EQUAL( disjoint(map_A, set_B), false );
BOOST_CHECK_EQUAL( disjoint(set_B, map_A), false );
BOOST_CHECK_EQUAL( disjoint(set_A, map_B), false );
@@ -867,8 +867,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -895,8 +895,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -923,8 +923,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -953,8 +953,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1006,8 +1006,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1056,8 +1056,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1096,8 +1096,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1129,8 +1129,8 @@
template <template<class T, class U,
class Traits = partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1147,9 +1147,9 @@
IntervalMapT map_a;
map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
- BOOST_CHECK_EQUAL( itl::contains(map_a.set(CDv(2,10,4)), CDv(2,10,4)), true );
- BOOST_CHECK_EQUAL( itl::contains(map_a.set(K_v(4,5)), K_v(4,5)), true );
- BOOST_CHECK_EQUAL( itl::contains(map_a.set(K_v(4,5)).set(CDv(3,5,6)), CDv(3,5,6)), true );
+ BOOST_CHECK_EQUAL( icl::contains(map_a.set(CDv(2,10,4)), CDv(2,10,4)), true );
+ BOOST_CHECK_EQUAL( icl::contains(map_a.set(K_v(4,5)), K_v(4,5)), true );
+ BOOST_CHECK_EQUAL( icl::contains(map_a.set(K_v(4,5)).set(CDv(3,5,6)), CDv(3,5,6)), true );
}
@@ -1157,8 +1157,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -1168,8 +1168,8 @@
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef typename IntervalMapT::interval_type IntervalT;
typedef typename IntervalMap<T,U,Trt>::set_type IntervalSetT;
- typedef itl::map<T,U,Trt> MapT;
- typedef itl::set<T> SetT;
+ typedef icl::map<T,U,Trt> MapT;
+ typedef icl::set<T> SetT;
IntervalMapT itv_map_sub_a, itv_map_a, itv_map_a2, itv_map_super_a,
itv_map_b, itv_map_c;
@@ -1196,9 +1196,9 @@
BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_c), inclusion::unrelated );
IntervalSetT set_sub_a, set_a, set_a2, set_b, set_c;
- itl::domain(set_a, itv_map_a);
- itl::domain(set_a2, itv_map_a2);
- itl::domain(set_sub_a, itv_map_sub_a);
+ icl::domain(set_a, itv_map_a);
+ icl::domain(set_a2, itv_map_a2);
+ icl::domain(set_sub_a, itv_map_sub_a);
BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalSetT()), inclusion::equal );
BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalMapT()), inclusion::equal );
@@ -1229,8 +1229,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -1271,8 +1271,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
Modified: sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,8 +13,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -44,8 +44,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -67,8 +67,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -93,8 +93,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -116,8 +116,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -142,8 +142,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -167,8 +167,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -196,8 +196,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -221,8 +221,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(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
+#define BOOST_TEST_MODULE icl::interval_set unit test
#include <string>
#include <vector>
#include <boost/mpl/list.hpp>
@@ -21,7 +21,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_interval_set_infix_/test_interval_set_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_infix_/test_interval_set_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_infix_/test_interval_set_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_set_infix unit test
+#define BOOST_TEST_MODULE icl::interval_set_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -245,15 +245,15 @@
split_interval_set<T> split_set;
split_set.add(I_D(0,4)).add(I_D(4,8));
- BOOST_CHECK_EQUAL( itl::contains(split_set, MK_v(4)), true );
- BOOST_CHECK_EQUAL( itl::contains(split_set, C_D(2,5)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_set, MK_v(4)), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_set, C_D(2,5)), true );
interval_set<T> join_set_gap4(split_set.erase(MK_v(4)));
- BOOST_CHECK_EQUAL( itl::contains(join_set_gap4, MK_v(4)), false );
- BOOST_CHECK_EQUAL( itl::contains(join_set_gap4, C_D(2,5)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_set_gap4, MK_v(4)), false );
+ BOOST_CHECK_EQUAL( icl::contains(join_set_gap4, C_D(2,5)), false );
- BOOST_CHECK_EQUAL( itl::contains(split_set, split_set), true );
- BOOST_CHECK_EQUAL( itl::contains(split_set, join_set_gap4), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_set, split_set), true );
+ BOOST_CHECK_EQUAL( icl::contains(split_set, join_set_gap4), true );
}
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval_set_mixed unit test
+#define BOOST_TEST_MODULE icl::interval_set_mixed unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_interval_set_mixed.hpp"
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -37,7 +37,7 @@
//empty set
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalSet<T>().empty(), true);
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalSet<T>()), true);
+ BOOST_CHECK_EQUAL(icl::is_empty(IntervalSet<T>()), true);
BOOST_CHECK_EQUAL(cardinality(IntervalSet<T>()), identity_element<size_T>::value());
BOOST_CHECK_EQUAL(IntervalSet<T>().size(), identity_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(IntervalSet<T>()), 0);
@@ -104,8 +104,8 @@
BOOST_CHECK_EQUAL(single_I0_0I_from_element, single_I0_0I_from_interval);
BOOST_CHECK_EQUAL(single_I0_0I_from_element, single_I0_0I);
- BOOST_CHECK_EQUAL(itl::hull(single_I0_0I).lower(), I0_0I.lower());
- BOOST_CHECK_EQUAL(itl::hull(single_I0_0I).upper(), I0_0I.upper());
+ BOOST_CHECK_EQUAL(icl::hull(single_I0_0I).lower(), I0_0I.lower());
+ BOOST_CHECK_EQUAL(icl::hull(single_I0_0I).upper(), I0_0I.upper());
IntervalSet<T> single_I1_1I_from_element(v1);
IntervalSet<T> single_I1_1I_from_interval(I1_1I);
@@ -123,19 +123,19 @@
BOOST_CHECK_EQUAL(hull(single_I0_1I).upper(), I0_1I.upper());
//contains predicate
- BOOST_CHECK_EQUAL(itl::contains(single_I0_0I, v0), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_0I, I0_0I), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I1_1I, v1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I1_1I, I1_1I), true);
-
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, v0), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, I0_1I), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, v1), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, I1_1I), true);
-
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, single_I0_0I), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, single_I1_1I), true);
- BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, single_I0_1I), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_0I, v0), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_0I, I0_0I), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I1_1I, v1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I1_1I, I1_1I), true);
+
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, v0), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, I0_1I), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, v1), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, I1_1I), true);
+
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, single_I0_0I), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, single_I1_1I), true);
+ BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, single_I0_1I), true);
BOOST_CHECK_EQUAL(cardinality(single_I0_0I), unit_element<size_T>::value());
BOOST_CHECK_EQUAL(single_I0_0I.size(), unit_element<size_T>::value());
@@ -300,7 +300,7 @@
BOOST_CHECK_EQUAL( cardinality(is_1_3_5), s3 );
BOOST_CHECK_EQUAL( is_1_3_5.size(), s3 );
- BOOST_CHECK_EQUAL( itl::length(is_1_3_5), d0 );
+ BOOST_CHECK_EQUAL( icl::length(is_1_3_5), d0 );
BOOST_CHECK_EQUAL( interval_count(is_1_3_5), 3 );
BOOST_CHECK_EQUAL( is_1_3_5.iterative_size(), 3 );
BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
@@ -311,9 +311,9 @@
is_123_5 = is_1_3_5;
is_123_5 += IntervalT::open(v1,v3);
- BOOST_CHECK_EQUAL( cardinality(is_123_5), itl::infinity<size_T>::value() );
- BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
- BOOST_CHECK_EQUAL( itl::length(is_123_5), d2 );
+ BOOST_CHECK_EQUAL( cardinality(is_123_5), icl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( is_123_5.size(), icl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( icl::length(is_123_5), d2 );
}
@@ -431,11 +431,11 @@
T v9 = make<T>(9);
T v11 = make<T>(11);
IntervalSet<T> is(v1);
- BOOST_CHECK_EQUAL( itl::contains(is, v1), true );
+ BOOST_CHECK_EQUAL( icl::contains(is, v1), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalSet<T>().add(make<T>(2)), make<T>(2)), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalSet<T>().insert(make<T>(2)), make<T>(2)), true );
- BOOST_CHECK_EQUAL( itl::contains((is += IntervalT(v3,v7)), IntervalT(v3,v7)), true );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalSet<T>().add(make<T>(2)), make<T>(2)), true );
+ BOOST_CHECK_EQUAL( icl::contains(IntervalSet<T>().insert(make<T>(2)), make<T>(2)), true );
+ BOOST_CHECK_EQUAL( icl::contains((is += IntervalT(v3,v7)), IntervalT(v3,v7)), true );
IntervalSet<T> is0 = is;
@@ -482,12 +482,12 @@
BOOST_CHECK_EQUAL( disjoint(section, complement), true );
BOOST_CHECK_EQUAL( all, all2 );
- BOOST_CHECK_EQUAL( itl::contains(all, left), true );
- BOOST_CHECK_EQUAL( itl::contains(all, right), true );
- BOOST_CHECK_EQUAL( itl::contains(all, complement), true );
+ BOOST_CHECK_EQUAL( icl::contains(all, left), true );
+ BOOST_CHECK_EQUAL( icl::contains(all, right), true );
+ BOOST_CHECK_EQUAL( icl::contains(all, complement), true );
- BOOST_CHECK_EQUAL( itl::contains(left, section), true );
- BOOST_CHECK_EQUAL( itl::contains(right, section), true );
+ BOOST_CHECK_EQUAL( icl::contains(left, section), true );
+ BOOST_CHECK_EQUAL( icl::contains(right, section), true );
BOOST_CHECK_EQUAL( within(left, all), true );
BOOST_CHECK_EQUAL( within(right, all), true );
Modified: sandbox/itl/libs/itl/test/test_itl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -20,16 +20,16 @@
// An empty interval is defined as the closed interval [1,0]
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(icl::is_empty(IntervalT()), true);
+ BOOST_CHECK_EQUAL(icl::cardinality(IntervalT()), icl::identity_element<typename icl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(icl::size(IntervalT()), icl::identity_element<typename icl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL(IntervalT().lower(), lower_bound);
- BOOST_CHECK_EQUAL(IntervalT().upper(), itl::identity_element<T>::value());
- BOOST_CHECK_EQUAL(itl::lower(IntervalT()), lower_bound);
- BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), icl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(icl::lower(IntervalT()), lower_bound);
+ BOOST_CHECK_EQUAL(icl::upper(IntervalT()), icl::identity_element<T>::value());
BOOST_CHECK_EQUAL(IntervalT(), IntervalT());
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(lower_bound, itl::identity_element<T>::value()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(lower_bound, icl::identity_element<T>::value()));
}
#endif // __test_itl_interval_hpp_JOFA_081006__
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::interval unit test
+#define BOOST_TEST_MODULE icl::interval unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -19,7 +19,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
#include "../test_itl_interval_shared.hpp"
#include "../test_icl_interval.hpp"
Modified: sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -18,10 +18,10 @@
typedef interval_set<DomainT,Compare,Interval> ItvSetT;
typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) IntervalT;
- BOOST_CHECK_EQUAL(itl::length(inner_complement(itv1,itv2)), itl::distance(itv1,itv2));
- BOOST_CHECK_EQUAL(itl::length(inner_complement(itv1,itv2)), itl::distance(itv2,itv1));
- BOOST_CHECK_EQUAL(itl::length(inner_complement(itv2,itv1)), itl::distance(itv1,itv2));
- BOOST_CHECK_EQUAL(itl::length(inner_complement(itv2,itv1)), itl::distance(itv2,itv1));
+ BOOST_CHECK_EQUAL(icl::length(inner_complement(itv1,itv2)), icl::distance(itv1,itv2));
+ BOOST_CHECK_EQUAL(icl::length(inner_complement(itv1,itv2)), icl::distance(itv2,itv1));
+ BOOST_CHECK_EQUAL(icl::length(inner_complement(itv2,itv1)), icl::distance(itv1,itv2));
+ BOOST_CHECK_EQUAL(icl::length(inner_complement(itv2,itv1)), icl::distance(itv2,itv1));
IntervalT in_comp = inner_complement(itv1,itv2);
ItvSetT itvset, inner_comp;
@@ -34,23 +34,23 @@
BOOST_CHECK_EQUAL(inner_complement(itv1,itv2), inner_comp_itv);
BOOST_CHECK_EQUAL(inner_complement(itv2,itv1), inner_comp_itv);
- BOOST_CHECK_EQUAL(itl::length(inner_comp), itl::distance(itv1,itv2));
- BOOST_CHECK_EQUAL(itl::length(inner_comp), itl::distance(itv2,itv1));
+ BOOST_CHECK_EQUAL(icl::length(inner_comp), icl::distance(itv1,itv2));
+ BOOST_CHECK_EQUAL(icl::length(inner_comp), icl::distance(itv2,itv1));
- BOOST_CHECK(itl::disjoint(itv1, in_comp));
- BOOST_CHECK(itl::disjoint(itv2, in_comp));
+ BOOST_CHECK(icl::disjoint(itv1, in_comp));
+ BOOST_CHECK(icl::disjoint(itv2, in_comp));
IntervalT itv1_comp = hull(itv1, in_comp);
IntervalT itv2_comp = hull(itv2, in_comp);
- if(!itl::is_empty(in_comp))
+ if(!icl::is_empty(in_comp))
{
- BOOST_CHECK(itl::intersects(itv1_comp, in_comp));
- BOOST_CHECK(itl::intersects(itv2_comp, in_comp));
+ BOOST_CHECK(icl::intersects(itv1_comp, in_comp));
+ BOOST_CHECK(icl::intersects(itv2_comp, in_comp));
BOOST_CHECK_EQUAL(itv1_comp & itv2_comp, in_comp);
- BOOST_CHECK_EQUAL( itl::is_empty(itv1_comp & itv2_comp), itl::disjoint(itv1_comp, itv2_comp));
- BOOST_CHECK_EQUAL(!itl::is_empty(itv1_comp & itv2_comp), itl::intersects(itv1_comp, itv2_comp));
+ BOOST_CHECK_EQUAL( icl::is_empty(itv1_comp & itv2_comp), icl::disjoint(itv1_comp, itv2_comp));
+ BOOST_CHECK_EQUAL(!icl::is_empty(itv1_comp & itv2_comp), icl::intersects(itv1_comp, itv2_comp));
}
}
@@ -67,15 +67,15 @@
void interval_ctor_specific()
{
- BOOST_CHECK_EQUAL(itl::length(itl::interval<double>::type()), 0.0);
- BOOST_CHECK_EQUAL(itl::cardinality(itl::interval<double>::closed(5.0, 5.0)), 1);
- BOOST_CHECK_EQUAL(itl::cardinality(itl::interval<std::string>::closed("test", "test")), 1);
- BOOST_CHECK_EQUAL(itl::cardinality(itl::interval<std::string>::closed("best","test")),
- itl::cardinality(itl::interval<double>::closed(0.0,0.1)));
- BOOST_CHECK_EQUAL(itl::cardinality(itl::interval<std::string>::right_open("best","test")),
- itl::infinity<size_type_of<itl::interval<std::string>::type>::type >::value() );
- BOOST_CHECK_EQUAL(itl::cardinality(itl::interval<double>::right_open(0.0, 1.0)),
- itl::infinity<size_type_of<itl::interval<double>::type>::type >::value() );
+ BOOST_CHECK_EQUAL(icl::length(icl::interval<double>::type()), 0.0);
+ BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<double>::closed(5.0, 5.0)), 1);
+ BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<std::string>::closed("test", "test")), 1);
+ BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<std::string>::closed("best","test")),
+ icl::cardinality(icl::interval<double>::closed(0.0,0.1)));
+ BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<std::string>::right_open("best","test")),
+ icl::infinity<size_type_of<icl::interval<std::string>::type>::type >::value() );
+ BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<double>::right_open(0.0, 1.0)),
+ icl::infinity<size_type_of<icl::interval<double>::type>::type >::value() );
}
#endif // ndef ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
@@ -83,7 +83,7 @@
template <class T>
void interval_equal_4_integral_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
T v2 = make<T>(2);
T v3 = make<T>(3);
T v7 = make<T>(7);
@@ -93,10 +93,10 @@
//I: (I)nside = closed bound
//C: left open bound
//D: right open bound
- IntervalT I3_7I = itl::interval<T>::closed(v3,v7);
- IntervalT I3__8D = itl::interval<T>::right_open(v3,v8);
- IntervalT C2__7I = itl::interval<T>::left_open(v2,v7);
- IntervalT C2___8D = itl::interval<T>::open(v2,v8);
+ IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
+ IntervalT I3__8D = icl::interval<T>::right_open(v3,v8);
+ IntervalT C2__7I = icl::interval<T>::left_open(v2,v7);
+ IntervalT C2___8D = icl::interval<T>::open(v2,v8);
BOOST_CHECK_EQUAL( I3_7I , I3_7I );
BOOST_CHECK_EQUAL( I3_7I , I3__8D );
@@ -116,28 +116,28 @@
template <class T>
void interval_less_4_integral_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
T v2 = make<T>(2);
T v3 = make<T>(3);
T v4 = make<T>(4);
T v7 = make<T>(7);
T v8 = make<T>(8);
BOOST_CHECK_EQUAL(IntervalT() < IntervalT(v7,v3), false);
- BOOST_CHECK_EQUAL(itl::interval<T>::open(v2,v3) < itl::interval<T>::right_open(v7,v7), false);
- BOOST_CHECK_EQUAL(itl::interval<T>::left_open(v3,v3) < itl::interval<T>::closed(v7,v3), false);
+ BOOST_CHECK_EQUAL(icl::interval<T>::open(v2,v3) < icl::interval<T>::right_open(v7,v7), false);
+ BOOST_CHECK_EQUAL(icl::interval<T>::left_open(v3,v3) < icl::interval<T>::closed(v7,v3), false);
BOOST_CHECK_EQUAL(IntervalT() < IntervalT(v3,v4), true);
- BOOST_CHECK_EQUAL(itl::interval<T>::open(v2,v3) < itl::interval<T>::right_open(v7,v8), true);
+ BOOST_CHECK_EQUAL(icl::interval<T>::open(v2,v3) < icl::interval<T>::right_open(v7,v8), true);
//I: (I)nside = closed bound
//C: left open bound
//D: right open bound
- IntervalT I3_7I = itl::interval<T>::closed(v3,v7);
- IntervalT I4_7I = itl::interval<T>::closed(v4,v7);
+ IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
+ IntervalT I4_7I = icl::interval<T>::closed(v4,v7);
- IntervalT I3__8D = itl::interval<T>::right_open(v3,v8);
- IntervalT C2__7I = itl::interval<T>::left_open(v2,v7);
- IntervalT C2___8D = itl::interval<T>::open(v2,v8);
+ IntervalT I3__8D = icl::interval<T>::right_open(v3,v8);
+ IntervalT C2__7I = icl::interval<T>::left_open(v2,v7);
+ IntervalT C2___8D = icl::interval<T>::open(v2,v8);
BOOST_CHECK_EQUAL( I3_7I < I3_7I , false);
BOOST_CHECK_EQUAL( I3_7I < I3__8D , false);
@@ -160,17 +160,17 @@
template <class T>
void interval_equal_4_bicremental_continuous_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
T v3 = make<T>(3);
T v7 = make<T>(7);
BOOST_CHECK_EQUAL(IntervalT(), IntervalT(v7,v3));
//I: (I)nside = closed bound
//O: (O)utside = open bound
- IntervalT I3_7I = itl::interval<T>::closed(v3,v7);
- IntervalT I3_7D = itl::interval<T>::right_open(v3,v7);
- IntervalT C3_7I = itl::interval<T>::left_open(v3,v7);
- IntervalT C3_7D = itl::interval<T>::open(v3,v7);
+ IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
+ IntervalT I3_7D = icl::interval<T>::right_open(v3,v7);
+ IntervalT C3_7I = icl::interval<T>::left_open(v3,v7);
+ IntervalT C3_7D = icl::interval<T>::open(v3,v7);
BOOST_CHECK_EQUAL( I3_7I , I3_7I );
BOOST_CHECK_EQUAL( I3_7I == I3_7D, false );
@@ -196,53 +196,53 @@
template <class T>
void interval_touches_4_bicremental_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
T v3 = make<T>(3);
T v7 = make<T>(7);
T v9 = make<T>(9);
- IntervalT I3_7D = itl::interval<T>::right_open(v3,v7);
- IntervalT I7_9I = itl::interval<T>::closed(v7,v9);
- BOOST_CHECK_EQUAL( itl::touches(I3_7D, I7_9I), true );
-
- IntervalT I3_7I = itl::interval<T>::closed(v3,v7);
- IntervalT C7_9I = itl::interval<T>::left_open(v7,v9);
- BOOST_CHECK_EQUAL( itl::touches(I3_7I, C7_9I), true );
+ IntervalT I3_7D = icl::interval<T>::right_open(v3,v7);
+ IntervalT I7_9I = icl::interval<T>::closed(v7,v9);
+ BOOST_CHECK_EQUAL( icl::touches(I3_7D, I7_9I), true );
+
+ IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
+ IntervalT C7_9I = icl::interval<T>::left_open(v7,v9);
+ BOOST_CHECK_EQUAL( icl::touches(I3_7I, C7_9I), true );
- BOOST_CHECK_EQUAL( itl::touches(I3_7D, C7_9I), false );
- BOOST_CHECK_EQUAL( itl::touches(I3_7I, I7_9I), false );
+ BOOST_CHECK_EQUAL( icl::touches(I3_7D, C7_9I), false );
+ BOOST_CHECK_EQUAL( icl::touches(I3_7I, I7_9I), false );
}
template <class T>
void interval_touches_4_integral_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
T v3 = make<T>(3);
T v6 = make<T>(6);
T v7 = make<T>(7);
T v9 = make<T>(9);
- IntervalT I3_6I = itl::interval<T>::closed(v3,v6);
- IntervalT I7_9I = itl::interval<T>::closed(v7,v9);
- BOOST_CHECK_EQUAL( itl::touches(I3_6I, I7_9I), true );
-
- IntervalT I3_7D = itl::interval<T>::right_open(v3,v7);
- IntervalT C6_9I = itl::interval<T>::left_open(v6,v9);
- BOOST_CHECK_EQUAL( itl::touches(I3_7D, C6_9I), true );
+ IntervalT I3_6I = icl::interval<T>::closed(v3,v6);
+ IntervalT I7_9I = icl::interval<T>::closed(v7,v9);
+ BOOST_CHECK_EQUAL( icl::touches(I3_6I, I7_9I), true );
+
+ IntervalT I3_7D = icl::interval<T>::right_open(v3,v7);
+ IntervalT C6_9I = icl::interval<T>::left_open(v6,v9);
+ BOOST_CHECK_EQUAL( icl::touches(I3_7D, C6_9I), true );
}
template <class T>
void interval_infix_intersect_4_bicremental_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
IntervalT section;
IntervalT I3_7D = I_D(3,7);
IntervalT I0_3D = I_D(0,3);
section = I3_7D & I0_3D;
- BOOST_CHECK_EQUAL( itl::disjoint(I0_3D, I3_7D), true );
- BOOST_CHECK_EQUAL( itl::is_empty(section), true );
+ BOOST_CHECK_EQUAL( icl::disjoint(I0_3D, I3_7D), true );
+ BOOST_CHECK_EQUAL( icl::is_empty(section), true );
BOOST_CHECK_EQUAL( section, IntervalT() );
IntervalT I0_5D = I_D(0,5);
@@ -267,15 +267,15 @@
IntervalT I7_9I = I_I(7,9);
section = I3_7D & I7_9I;
- BOOST_CHECK_EQUAL( itl::exclusive_less(I3_7D, I7_9I), true );
- BOOST_CHECK_EQUAL( itl::disjoint(I3_7D, I7_9I), true );
- BOOST_CHECK_EQUAL( itl::is_empty(section), true );
+ BOOST_CHECK_EQUAL( icl::exclusive_less(I3_7D, I7_9I), true );
+ BOOST_CHECK_EQUAL( icl::disjoint(I3_7D, I7_9I), true );
+ BOOST_CHECK_EQUAL( icl::is_empty(section), true );
}
template <class T>
void interval_subtract_4_bicremental_types()
{
- typedef typename itl::interval<T>::type IntervalT;
+ typedef typename icl::interval<T>::type IntervalT;
IntervalT diff_1, diff_2;
IntervalT I0_3D = I_D(0,3);
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,8 +13,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -22,8 +22,8 @@
void itl_map_contains_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- typedef itl::set<T> SetT;
+ typedef icl::map<T,U,Trt> MapT;
+ typedef icl::set<T> SetT;
typedef typename MapT::element_type map_element_type;
IntervalMapT itv_map_a;
@@ -50,8 +50,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -59,7 +59,7 @@
void itl_map_find_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::map<T,U,Trt> MapT;
IntervalMapT itv_map_a;
itv_map_a.add(IDv(2,4,1)).add(IIv(6,7,3));
@@ -83,8 +83,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -92,8 +92,8 @@
void itl_map_inclusion_compare_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- typedef itl::set<T> SetT;
+ typedef icl::map<T,U,Trt> MapT;
+ typedef icl::set<T> SetT;
IntervalMapT itv_map_sub_a, itv_map_a, itv_map_super_a,
itv_map_b, itv_map_c;
@@ -125,9 +125,9 @@
BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_c), inclusion::unrelated );
SetT set_sub_a, set_a, set_a2, set_b, set_c;
- itl::domain(set_a, map_a);
- itl::domain(set_a2, map_a2);
- itl::domain(set_sub_a, map_sub_a);
+ icl::domain(set_a, map_a);
+ icl::domain(set_a2, map_a2);
+ icl::domain(set_sub_a, map_sub_a);
BOOST_CHECK_EQUAL( inclusion_compare(MapT(), SetT()), inclusion::equal );
BOOST_CHECK_EQUAL( inclusion_compare(SetT(), MapT()), inclusion::equal );
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::itl_map unit test
+#define BOOST_TEST_MODULE icl::itl_map unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/identity_element.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template<class Type>
@@ -416,10 +416,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, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -427,10 +427,10 @@
void check_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -456,10 +456,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, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -467,10 +467,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)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -496,10 +496,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, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -507,10 +507,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)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -536,10 +536,10 @@
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, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(op_tag) \
@@ -547,10 +547,10 @@
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)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -715,7 +715,7 @@
#define CHECK_ABELIAN_GROUP_INSTANCE_WRT(op_tag) check_abelian_group_instance_wrt_##op_tag
#define CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(op_tag) check_abelian_group_instance_wrt_equal_##op_tag
-}} // namespace itl boost
+}} // namespace icl boost
#endif // __test_itl_laws_h_JOFA_080920__
Modified: sandbox/itl/libs/itl/test/test_partial_icl_quantifier_/test_partial_icl_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_partial_icl_quantifier_/test_partial_icl_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/test_partial_icl_quantifier_/test_partial_icl_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::partial_icl_quantifier unit test
+#define BOOST_TEST_MODULE icl::partial_icl_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_partial_interval_quantifier_/test_partial_interval_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_partial_interval_quantifier_/test_partial_interval_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/test_partial_interval_quantifier_/test_partial_interval_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::partial_interval_quantifier unit test
+#define BOOST_TEST_MODULE icl::partial_interval_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,8 +16,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -25,7 +25,7 @@
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -49,8 +49,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -58,7 +58,7 @@
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -85,8 +85,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -94,7 +94,7 @@
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -118,8 +118,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -127,7 +127,7 @@
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -154,8 +154,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -163,7 +163,7 @@
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -189,8 +189,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -198,7 +198,7 @@
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -228,8 +228,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -237,7 +237,7 @@
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
@@ -263,8 +263,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -272,7 +272,7 @@
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
+ typedef icl::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));
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,8 +16,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -43,8 +43,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -73,8 +73,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -100,8 +100,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -130,8 +130,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -159,8 +159,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -192,8 +192,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -221,8 +221,8 @@
template<class T, class U,
class Traits = Trt,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
- ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(icl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(icl::inter_section, U),
ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::separate_interval_set unit test
+#define BOOST_TEST_MODULE icl::separate_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_separate_interval_set_infix_/test_separate_interval_set_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_separate_interval_set_infix_/test_separate_interval_set_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/test_separate_interval_set_infix_/test_separate_interval_set_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::separate_interval_set_infix unit test
+#define BOOST_TEST_MODULE icl::separate_interval_set_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_set_interval_set_/test_set_interval_set.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_interval_set_/test_set_interval_set.cpp (original)
+++ sandbox/itl/libs/itl/test/test_set_interval_set_/test_set_interval_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::set_interval_set unit test
+#define BOOST_TEST_MODULE icl::set_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -23,7 +23,7 @@
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- typedef itl::set<T> SetT;
+ typedef icl::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));
@@ -54,7 +54,7 @@
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- typedef itl::set<T> SetT;
+ typedef icl::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));
@@ -88,7 +88,7 @@
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- typedef itl::set<T> SetT;
+ typedef icl::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));
@@ -118,7 +118,7 @@
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- typedef itl::set<T> SetT;
+ typedef icl::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));
@@ -152,7 +152,7 @@
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- typedef itl::set<T> SetT;
+ typedef icl::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));
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::set_itl_set unit test
+#define BOOST_TEST_MODULE icl::set_itl_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -24,7 +24,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_set_itl_set_/test_set_itl_set_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_itl_set_/test_set_itl_set_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_itl_set_/test_set_itl_set_cases.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
{ itl_set_check_monoid_plus_4_bicremental_types<T, interval_set>();}
//MEMO: interval_set
// is used here pragmatically to be able to recycle test code for initializing
-// sets. These interval_set are then converted to itl::set by atomize.
+// sets. These interval_set are then converted to icl::set by atomize.
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_itl_set_check_abelian_monoid_plus_4_bicremental_types, T, discrete_types)
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::split_interval_map unit test
+#define BOOST_TEST_MODULE icl::split_interval_map unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_split_interval_map_infix_/test_split_interval_map_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_split_interval_map_infix_/test_split_interval_map_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/test_split_interval_map_infix_/test_split_interval_map_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::split_interval_map_infix unit test
+#define BOOST_TEST_MODULE icl::split_interval_map_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -23,7 +23,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_map_shared are tests that should give identical results for all
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(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
+#define BOOST_TEST_MODULE icl::split_interval_set unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_split_interval_set_infix_/test_split_interval_set_infix.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_split_interval_set_infix_/test_split_interval_set_infix.cpp (original)
+++ sandbox/itl/libs/itl/test/test_split_interval_set_infix_/test_split_interval_set_infix.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::split_interval_set_infix unit test
+#define BOOST_TEST_MODULE icl::split_interval_set_infix unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -20,7 +20,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_total_icl_quantifier_/test_total_icl_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_total_icl_quantifier_/test_total_icl_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/test_total_icl_quantifier_/test_total_icl_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::total_icl_quantifier unit test
+#define BOOST_TEST_MODULE icl::total_icl_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
Modified: sandbox/itl/libs/itl/test/test_total_interval_quantifier_/test_total_interval_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_total_interval_quantifier_/test_total_interval_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/test_total_interval_quantifier_/test_total_interval_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -5,7 +5,7 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#define BOOST_TEST_MODULE itl::total_interval_quantifier unit test
+#define BOOST_TEST_MODULE icl::total_interval_quantifier unit test
#include <string>
#include <boost/mpl/list.hpp>
#include "../unit_test_unwarned.hpp"
@@ -22,7 +22,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
// -----------------------------------------------------------------------------
// test_interval_set_shared are tests that should give identical results for all
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/interval_bounds.hpp>
-namespace boost{ namespace itl
+namespace boost{ namespace icl
{
/*FYI completion like that:
@@ -134,13 +134,13 @@
// Very short value denotation for intervals
// Assumption typename T and IntervalT exists in scope
//I_I : [a,b]
-#define I_I(low,up) itl::interval<T>::closed (make<T>(low), make<T>(up))
+#define I_I(low,up) icl::interval<T>::closed (make<T>(low), make<T>(up))
//I_D : [a,b)
-#define I_D(low,up) itl::interval<T>::right_open(make<T>(low), make<T>(up))
+#define I_D(low,up) icl::interval<T>::right_open(make<T>(low), make<T>(up))
//C_I : (a,b]
-#define C_I(low,up) itl::interval<T>::left_open (make<T>(low), make<T>(up))
+#define C_I(low,up) icl::interval<T>::left_open (make<T>(low), make<T>(up))
//C_D : (a,b)
-#define C_D(low,up) itl::interval<T>::open (make<T>(low), make<T>(up))
+#define C_D(low,up) icl::interval<T>::open (make<T>(low), make<T>(up))
#define MK_I(ItvT,low,up) ItvT(make<T>(low), make<T>(up))
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -19,7 +19,7 @@
#include <sstream>
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
/** Example amount_cube.cpp \file amount_cube.cpp
\brief Demonstrates computations of aggregates using maps of tuples or <i>cubes</i>
@@ -225,7 +225,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample amount_cube.cpp <<\n";
+ cout << ">>Interval Container Library: Sample amount_cube.cpp <<\n";
cout << "-------------------------------------------------------\n";
cout << "Note that there is always a representing value for a tupel component\n";
cout << "even if the component is grouped or switched off.\n";
@@ -240,7 +240,7 @@
// Program output
-// >> Interval Template Library: Sample amount_cube.cpp <<
+// >>Interval Container Library: Sample amount_cube.cpp <<
// -------------------------------------------------------
// Note that there is always a representing value for a tupel component
// even if the component is grouped or switched off.
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
@@ -87,7 +87,7 @@
#include <boost/itl_xt/product_history.hpp>
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
/* To use a product_history object, we need an TypeDomain-class, specifying
@@ -229,7 +229,7 @@
int main()
{
- cout << ">> Interval Template Library: Sample history.cpp <<\n";
+ cout << ">>Interval Container Library: Sample history.cpp <<\n";
cout << "---------------------------------------------------\n";
medical_file();
return 0;
@@ -237,7 +237,7 @@
// Program output:
-// >> Interval Template Library: Sample history.cpp <<
+// >>Interval Container Library: Sample history.cpp <<
// ---------------------------------------------------
// [mon:22:00,mon:22:05): DIAG{susp.cran.frac.}, WARD{emergency_ward}
// [mon:22:05,mon:22:15): DIAG{alc.intox. susp.cran.frac.}, WARD{emergency_ward}
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#pragma warning(disable:4996) // This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
#endif
-namespace boost{namespace itl
+namespace boost{namespace icl
{
/** Time is a toy-class to demonstrate a class that conforms the requirements of
@@ -69,5 +69,5 @@
#pragma warning(pop)
#endif
-}} // namespace itl boost
+}} // namespace icl boost
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -47,7 +47,7 @@
#include "../itvsettester.h"
using namespace std;
-using namespace boost::itl;
+using namespace boost::icl;
// -------------------------------------------------
void autoPropertyTest_ItvSet_int()
@@ -149,7 +149,7 @@
{
// Select a test by (re)moving the comment tokens!
- cout << ">> Interval Template Library: Test auto_itv_test.cpp <<\n";
+ cout << ">>Interval Container Library: Test auto_itv_test.cpp <<\n";
cout << "-------------------------------------------------------\n";
// Test programmed properties on a sample of generated interval_set<int>
//autoPropertyTest_ItvSet_int();
Modified: sandbox/itl/libs/itl_xt/test/itvmaptester.h
==============================================================================
--- sandbox/itl/libs/itl_xt/test/itvmaptester.h (original)
+++ sandbox/itl/libs/itl_xt/test/itvmaptester.h 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -7,7 +7,7 @@
#include <boost/itl_xt/itvgentor.hpp>
#include <boost/itl_xt/mapgentor.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class ItvMapTV>
@@ -543,7 +543,7 @@
return correct;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -34,7 +34,7 @@
#include <boost/itl_xt/setgentor.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class ItvSetTV>
@@ -598,7 +598,7 @@
return correct;
}
-}} // namespace itl boost
+}} // namespace icl boost
#endif
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -19,7 +19,7 @@
using namespace std;
using namespace boost;
using namespace boost::mpl::placeholders;
-using namespace boost::itl;
+using namespace boost::icl;
template<class T>struct unary{
void speak(){ cout<<"unary"<<endl; }
@@ -162,7 +162,7 @@
int value()const { return _value; }
std::string as_string()const
- { return itl::to_string<int>::apply(_value); }
+ { return icl::to_string<int>::apply(_value); }
private:
int _value;
@@ -242,7 +242,7 @@
int main()
{
- cout << ">> Interval Template Library: Test meta_functors <<\n";
+ cout << ">>Interval Container Library: Test meta_functors <<\n";
cout << "-------------------------------------------------------\n";
/*
Modified: sandbox/itl/libs/validate/example/boostcon_abelian_monoids_/boostcon_abelian_monoids.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/boostcon_abelian_monoids_/boostcon_abelian_monoids.cpp (original)
+++ sandbox/itl/libs/validate/example/boostcon_abelian_monoids_/boostcon_abelian_monoids.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
int main()
{
Modified: sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp (original)
+++ sandbox/itl/libs/validate/example/boostcon_law_validater_/boostcon_law_validater.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,12 +16,12 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
using namespace boost::posix_time;
int main()
{
- typedef InplaceCommutativity<itl::list<int> > TestLawT;
+ typedef InplaceCommutativity<icl::list<int> > TestLawT;
LawValidater<TestLawT> law_validator;
//-----------------------------------------------------------------------------
Modified: sandbox/itl/libs/validate/example/de_morgan_/de_morgan.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/de_morgan_/de_morgan.cpp (original)
+++ sandbox/itl/libs/validate/example/de_morgan_/de_morgan.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -145,7 +145,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
using namespace boost::posix_time;
Modified: sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_bit_collector_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_collector_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_itl_morphic_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_itl_set_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_itv_bitset_/labat_itv_bitset.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itv_bitset_/labat_itv_bitset.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itv_bitset_/labat_itv_bitset.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_itl_set_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_map_copy_conformity_/labat_map_copy_conformity.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_map_copy_conformity_/labat_map_copy_conformity.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_map_copy_conformity_/labat_map_copy_conformity.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_Validater()
{
Modified: sandbox/itl/libs/validate/example/labat_map_order_/labat_map_order.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_map_order_/labat_map_order.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_map_order_/labat_map_order.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -25,7 +25,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_itl_order_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_polygon_/custom_polygon.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/custom_polygon.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/custom_polygon.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
#include "point_gentor.hpp"
#include "polygon_gentor.hpp"
-typedef boost::itl::point<int> CPoint;
+typedef boost::icl::point<int> CPoint;
namespace boost{ namespace polygon{
@@ -51,7 +51,7 @@
}}
//the CPolygon example
-typedef boost::itl::list<CPoint > CPolygon;
+typedef boost::icl::list<CPoint > CPolygon;
//we need to specialize our polygon concept mapping in gtl
namespace boost{ namespace polygon{
@@ -105,7 +105,7 @@
}}
//OK, finally we get to declare our own polygon set type
-typedef boost::itl::list<CPolygon> CPolygonSet;
+typedef boost::icl::list<CPolygon> CPolygonSet;
//deque isn't automatically a polygon set in the library
//because it is a standard container there is a shortcut
Modified: sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -32,7 +32,7 @@
namespace gtl = boost::polygon;
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
using namespace boost::posix_time;
using namespace boost::polygon::operators;
@@ -98,8 +98,8 @@
// This function tests the generator for polygon sets.
void test_polyset_gen()
{
- typedef itl::list<point<int> > PolygonT;
- typedef itl::list<PolygonT> PolygonSetT;
+ typedef icl::list<point<int> > PolygonT;
+ typedef icl::list<PolygonT> PolygonSetT;
point_gentor<int>* pointgen = new point_gentor<int>;
pointgen->setRange(interval<int>::right_open(-99, 100));
Modified: sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/itl_xt/numbergentor.hpp>
#include <boost/itl_xt/seqgentor.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
//toy point.
@@ -49,7 +49,7 @@
}
template <class Type>
-struct type_to_string<itl::point<Type> >
+struct type_to_string<icl::point<Type> >
{
static std::string apply()
{ return "point<"+ type_to_string<Type>::apply() +">"; }
@@ -61,11 +61,11 @@
public:
virtual void some(PointT& x);
- void setRange(const itl::interval<DomainT>& range)
+ void setRange(const icl::interval<DomainT>& range)
{ m_valueRange = range; }
void setValueRange(DomainT low, DomainT up)
- { m_valueRange.set(low,up, itl::right_open); }
+ { m_valueRange.set(low,up, icl::right_open); }
void setMaxIntervalLength(DomainT len) { m_maxIntervalLength=len; }
void setProbDerivation();
@@ -85,7 +85,7 @@
value.y = m_DomainTGentor(m_valueRange);
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif
Modified: sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/itl_xt/gentorit.hpp>
#include <boost/itl_xt/list.hpp>
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <class PolygonT>
Modified: sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -17,7 +17,7 @@
#include <boost/polygon/polygon.hpp>
#include "custom_polygon.hpp"
-namespace boost{namespace itl
+namespace boost{namespace icl
{
template <typename Type>
@@ -161,7 +161,7 @@
};
-}} // namespace itl boost
+}} // namespace icl boost
#endif // BOOST_ITL_POLYGON_LAWS_HPP_JOFA_070411
Modified: sandbox/itl/libs/validate/example/labat_set_copy_conformity_/labat_set_copy_conformity.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_set_copy_conformity_/labat_set_copy_conformity.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_set_copy_conformity_/labat_set_copy_conformity.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_Validater()
{
Modified: sandbox/itl/libs/validate/example/labat_set_order_/labat_set_order.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_set_order_/labat_set_order.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_set_order_/labat_set_order.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -25,7 +25,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_itl_order_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_signed_quantifier_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -41,7 +41,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
using namespace boost::posix_time;
@@ -50,45 +50,45 @@
//typedef UnaryAtomicEquivalence2
//<
- // itl::interval_map<int,int>,
- // //itl::list<int>,
+ // icl::interval_map<int,int>,
+ // //icl::list<int>,
// std::pair<int,int>,
- // itl::std_find
+ // icl::std_find
//> TestLawT;
//typedef InducedRelation
//<
- // itl::interval_map<int,int>,
- // itl::map<int,int>,
+ // icl::interval_map<int,int>,
+ // icl::map<int,int>,
// segmental::atomizer,
// element_equal
//>
//TestLawT;
- //typedef Antisymmetry<itl::map<int,int>, std::less_equal, std_equal> TestLawT;
+ //typedef Antisymmetry<icl::map<int,int>, std::less_equal, std_equal> TestLawT;
//typedef JointInverseExistence
- // <interval_map<int,int,partial_enricher>, itl::inplace_plus, itl::inplace_minus> TestLawT;
+ // <interval_map<int,int,partial_enricher>, icl::inplace_plus, icl::inplace_minus> TestLawT;
//LawValidater<TestLawT, RandomGentor> test_law;
- //typedef InplaceCommutativity<itl::set<double> > TestLawT;
+ //typedef InplaceCommutativity<icl::set<double> > TestLawT;
//LawValidater<TestLawT> test_law;
//typedef FunctionEquality
//<
- // itl::list<std::pair<right_open_interval<double,std::less>,int> >, //SourceT,
+ // icl::list<std::pair<right_open_interval<double,std::less>,int> >, //SourceT,
// split_interval_map<double,int,partial_absorber>, //TargetT,
// base_insertion,
// hint_insertion
//>
//TestLawT;
- //typedef Antisymmetry<itl::map<int,int>, itl::sub_super_set, itl::element_equal> TestLawT;
- //typedef InplaceAssociativity<itl::interval_map<int,itl::set<int> >, itl::inplace_caret, itl::element_equal> TestLawT;
+ //typedef Antisymmetry<icl::map<int,int>, icl::sub_super_set, icl::element_equal> TestLawT;
+ //typedef InplaceAssociativity<icl::interval_map<int,icl::set<int> >, icl::inplace_caret, icl::element_equal> TestLawT;
- typedef InplaceFlip< itl::map<int,int,partial_enricher> > TestLawT;
- //typedef InplaceFlip< itl::map<int,int> > TestLawT;
- //typedef InplaceFlip< itl::map<int, itl::set<int> > > TestLawT;
+ typedef InplaceFlip< icl::map<int,int,partial_enricher> > TestLawT;
+ //typedef InplaceFlip< icl::map<int,int> > TestLawT;
+ //typedef InplaceFlip< icl::map<int, icl::set<int> > > TestLawT;
LawValidater<TestLawT> test_law;
Modified: sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_/labat_sorted_assoc_bitset.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_/labat_sorted_assoc_bitset.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_/labat_sorted_assoc_bitset.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_sorted_associative_bitset_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_back_/labat_sorted_assoc_bitset_back.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_back_/labat_sorted_assoc_bitset_back.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_sorted_assoc_bitset_back_/labat_sorted_assoc_bitset_back.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -14,7 +14,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_sorted_associative_bitset_back_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_sorted_assoc_map_/labat_sorted_assoc_map.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_sorted_assoc_map_/labat_sorted_assoc_map.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_sorted_assoc_map_/labat_sorted_assoc_map.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_sorted_associative_map_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_sorted_assoc_map_back_/labat_sorted_assoc_map_back.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_sorted_assoc_map_back_/labat_sorted_assoc_map_back.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_sorted_assoc_map_back_/labat_sorted_assoc_map_back.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_sorted_associative_map_back_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_sorted_assoc_set_/labat_sorted_assoc_set.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_sorted_assoc_set_/labat_sorted_assoc_set.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_sorted_assoc_set_/labat_sorted_assoc_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_sorted_associative_set_driver()
{
Modified: sandbox/itl/libs/validate/example/labat_sorted_assoc_set_back_/labat_sorted_assoc_set_back.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_sorted_assoc_set_back_/labat_sorted_assoc_set_back.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_sorted_assoc_set_back_/labat_sorted_assoc_set_back.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_sorted_associative_set_back_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -15,7 +15,7 @@
using namespace std;
using namespace Loki;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_unsigned_quantifier_driver()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -13,7 +13,7 @@
using namespace std;
using namespace boost;
-using namespace boost::itl;
+using namespace boost::icl;
void test_Validater()
{
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 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Interval Template Library
+Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
+------------------------------------------------------------------------------+
@@ -9,7 +9,7 @@
+-----------------------------------------------------------------------------*/
#include <boost/validate/gentor/gentorprofile.hpp>
-using namespace boost::itl;
+using namespace boost::icl;
GentorProfileSgl* GentorProfileSgl::s_instance = NULL;
@@ -151,5 +151,5 @@
// -------------------------------------
// (Algebra, Law, Type) -> (testsCount)
-// (set, ipAddCommut, itl::set) -> 150
+// (set, ipAddCommut, icl::set) -> 150
Modified: sandbox/itl/libs/validate/test/test_bit_collector_/test_bit_collector.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_bit_collector_/test_bit_collector.cpp (original)
+++ sandbox/itl/libs/validate/test/test_bit_collector_/test_bit_collector.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_bit_collector)
{
Modified: sandbox/itl/libs/validate/test/test_collector_/test_collector.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_collector_/test_collector.cpp (original)
+++ sandbox/itl/libs/validate/test/test_collector_/test_collector.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_collector)
{
Modified: sandbox/itl/libs/validate/test/test_interval_bitset_/test_interval_bitset.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_interval_bitset_/test_interval_bitset.cpp (original)
+++ sandbox/itl/libs/validate/test/test_interval_bitset_/test_interval_bitset.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_interval_bitset)
{
Modified: sandbox/itl/libs/validate/test/test_itl_morphic_/test_itl_morphic.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_itl_morphic_/test_itl_morphic.cpp (original)
+++ sandbox/itl/libs/validate/test/test_itl_morphic_/test_itl_morphic.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_itl_morphic)
{
Modified: sandbox/itl/libs/validate/test/test_itl_set_/test_itl_set.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_itl_set_/test_itl_set.cpp (original)
+++ sandbox/itl/libs/validate/test/test_itl_set_/test_itl_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_itl_set)
{
Modified: sandbox/itl/libs/validate/test/test_map_copy_conformity_/test_map_copy_conformity.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_map_copy_conformity_/test_map_copy_conformity.cpp (original)
+++ sandbox/itl/libs/validate/test/test_map_copy_conformity_/test_map_copy_conformity.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_map_copy_conformity)
{
Modified: sandbox/itl/libs/validate/test/test_map_order_/test_map_order.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_map_order_/test_map_order.cpp (original)
+++ sandbox/itl/libs/validate/test/test_map_order_/test_map_order.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_map_order)
{
Modified: sandbox/itl/libs/validate/test/test_set_copy_conformity_/test_set_copy_conformity.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_set_copy_conformity_/test_set_copy_conformity.cpp (original)
+++ sandbox/itl/libs/validate/test/test_set_copy_conformity_/test_set_copy_conformity.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_set_copy_conformity)
{
Modified: sandbox/itl/libs/validate/test/test_set_order_/test_set_order.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_set_order_/test_set_order.cpp (original)
+++ sandbox/itl/libs/validate/test/test_set_order_/test_set_order.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_set_order)
{
Modified: sandbox/itl/libs/validate/test/test_signed_quantifier_/test_signed_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_signed_quantifier_/test_signed_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/test/test_signed_quantifier_/test_signed_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_signed_quantifier)
{
Modified: sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_/test_sorted_assoc_bitset.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_/test_sorted_assoc_bitset.cpp (original)
+++ sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_/test_sorted_assoc_bitset.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_sorted_associative_bitset)
{
Modified: sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_back_/test_sorted_assoc_bitset_back.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_back_/test_sorted_assoc_bitset_back.cpp (original)
+++ sandbox/itl/libs/validate/test/test_sorted_assoc_bitset_back_/test_sorted_assoc_bitset_back.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_sorted_associative_bitset_back)
{
Modified: sandbox/itl/libs/validate/test/test_sorted_assoc_map_/test_sorted_assoc_map.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_sorted_assoc_map_/test_sorted_assoc_map.cpp (original)
+++ sandbox/itl/libs/validate/test/test_sorted_assoc_map_/test_sorted_assoc_map.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_sorted_associative_map)
{
Modified: sandbox/itl/libs/validate/test/test_sorted_assoc_map_back_/test_sorted_assoc_map_back.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_sorted_assoc_map_back_/test_sorted_assoc_map_back.cpp (original)
+++ sandbox/itl/libs/validate/test/test_sorted_assoc_map_back_/test_sorted_assoc_map_back.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_sorted_associative_map_back)
{
Modified: sandbox/itl/libs/validate/test/test_sorted_assoc_set_/test_sorted_assoc_set.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_sorted_assoc_set_/test_sorted_assoc_set.cpp (original)
+++ sandbox/itl/libs/validate/test/test_sorted_assoc_set_/test_sorted_assoc_set.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_sorted_associative_set)
{
Modified: sandbox/itl/libs/validate/test/test_sorted_assoc_set_back_/test_sorted_assoc_set_back.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_sorted_assoc_set_back_/test_sorted_assoc_set_back.cpp (original)
+++ sandbox/itl/libs/validate/test/test_sorted_assoc_set_back_/test_sorted_assoc_set_back.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_sorted_associative_set_back)
{
Modified: sandbox/itl/libs/validate/test/test_unsigned_quantifier_/test_unsigned_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_unsigned_quantifier_/test_unsigned_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/test/test_unsigned_quantifier_/test_unsigned_quantifier.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_unsigned_quantifier)
{
Modified: sandbox/itl/libs/validate/test/test_val_relations_/test_val_relations.cpp
==============================================================================
--- sandbox/itl/libs/validate/test/test_val_relations_/test_val_relations.cpp (original)
+++ sandbox/itl/libs/validate/test/test_val_relations_/test_val_relations.cpp 2010-10-15 04:57:34 EDT (Fri, 15 Oct 2010)
@@ -16,7 +16,7 @@
using namespace std;
using namespace boost;
using namespace unit_test;
-using namespace boost::itl;
+using namespace boost::icl;
BOOST_AUTO_TEST_CASE(test_validate_itl_val_relations)
{
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