|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r60791 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/validate/driver libs/itl/test libs/itl/test/test_casual_ libs/validate/example/labat_signed_quantifier_ libs/validate/example/labat_single_ libs/validate/example/labat_unsigned_quantifier_
From: afojgo_at_[hidden]
Date: 2010-03-23 08:08:41
Author: jofaber
Date: 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
New Revision: 60791
URL: http://svn.boost.org/trac/boost/changeset/60791
Log:
Fixes of 2 Bugs found by John Reid in the review:
(1) itl::infinity<T>::value checks T for existence of an infinity value and uses max otherwise.
(2) Template parameter Section is now defaulted with functor template itl::inter_section,
that chooses the right functor dependent on the CodomainT template parameter. For two interval_maps
a, b the expression (a & b) will now compile for most, if not all codomain_types that have some
reasonable application.
Added:
sandbox/itl/boost/itl/type_traits/infinity.hpp (contents, props changed)
sandbox/itl/boost/itl/type_traits/is_numeric.hpp (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 2
sandbox/itl/boost/itl/functors.hpp | 114 ++++++++++++++++++++++++---------------
sandbox/itl/boost/itl/interval.hpp | 3
sandbox/itl/boost/itl/interval_base_map.hpp | 5 +
sandbox/itl/boost/itl/interval_map.hpp | 2
sandbox/itl/boost/itl/map.hpp | 2
sandbox/itl/boost/itl/rational.hpp | 9 +++
sandbox/itl/boost/itl/split_interval_map.hpp | 2
sandbox/itl/boost/itl/type_traits/has_inverse.hpp | 5 +
sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp | 28 ++++----
sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp | 24 ++++----
sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp | 25 +++++++-
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 16 +++++
sandbox/itl/libs/itl/test/test_functions.hpp | 4
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 50 ++++++++--------
sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp | 21 ++++---
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 4
sandbox/itl/libs/itl/test/test_itl_map.hpp | 4
sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp | 16 ++--
sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 16 ++--
sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp | 25 +++++++-
sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp | 1
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 7 +
sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/vc9_labat_unsigned_quantifier.vcproj | 4 +
24 files changed, 243 insertions(+), 146 deletions(-)
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -30,7 +30,7 @@
ITL_const_FORALL(typename IntervalContainerT, it, object)
{
interval_size = continuous_interval<interval_type>::cardinality(IntervalContainerT::key_value(it));
- if(interval_size == std::numeric_limits<size_type>::infinity())
+ if(interval_size == infinity<size_type>::value())
return interval_size;
else
size += interval_size;
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -10,8 +10,10 @@
#include <functional>
#include <boost/type_traits.hpp>
+#include <boost/mpl/if.hpp>
#include <boost/itl/type_traits/neutron.hpp>
#include <boost/itl/type_traits/unon.hpp>
+#include <boost/itl/type_traits/is_set.hpp>
namespace boost{namespace itl
{
@@ -33,6 +35,7 @@
template <typename Type> struct inplace_identity
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_identity<Type> type;
void operator()(Type& object, const Type& operand)const{}
};
@@ -44,6 +47,8 @@
template <typename Type> struct inplace_erasure
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_erasure<Type> type;
+
void operator()(Type& object, const Type& operand)const
{
if(object == operand)
@@ -59,7 +64,7 @@
template <typename Type> struct inplace_plus
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_plus<Type> type;
void operator()(Type& object, const Type& operand)const
{ object += operand; }
@@ -74,7 +79,8 @@
template <typename Type> struct inplace_minus
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_minus<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ object -= operand; }
};
@@ -86,7 +92,7 @@
template <typename Type> struct inplace_bit_add
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_bit_add<Type> type;
void operator()(Type& object, const Type& operand)const
{ object |= operand; }
@@ -101,7 +107,8 @@
template <typename Type> struct inplace_bit_subtract
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_bit_subtract<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ object &= ~operand; }
@@ -115,7 +122,7 @@
template <typename Type> struct inplace_bit_and
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_bit_and<Type> type;
void operator()(Type& object, const Type& operand)const
{ object &= operand; }
@@ -128,7 +135,8 @@
template <typename Type> struct inplace_bit_xor
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_bit_xor<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
@@ -139,30 +147,12 @@
template <typename Type> struct inplace_et
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_et<Type> type;
void operator()(Type& object, const Type& operand)const
{ object &= operand; }
};
- template <> struct inplace_et<double>
- : public neutron_based_inplace_combine<double>
- {
- typedef double type;
-
- void operator()(type& object, type operand)const
- { object += operand; }
- };
-
- template <> struct inplace_et<float>
- : public neutron_based_inplace_combine<float>
- {
- typedef float type;
-
- void operator()(type& object, type operand)const
- { object += operand; }
- };
-
template<>
inline std::string unary_template_to_string<inplace_et>::apply() { return "&="; }
@@ -170,31 +160,14 @@
template <typename Type> struct inplace_caret
: public neutron_based_inplace_combine<Type>
{
- typedef Type type;
+ typedef inplace_caret<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
- template <> struct inplace_caret<double>
- : public neutron_based_inplace_combine<double>
- {
- typedef double type;
-
- void operator()(type& object, type operand)const
- { object -= operand; }
- };
-
- template <> struct inplace_caret<float>
- : public neutron_based_inplace_combine<float>
- {
- typedef float type;
-
- void operator()(type& object, type operand)const
- { object -= operand; }
- };
-
template<>
inline std::string unary_template_to_string<inplace_caret>::apply() { return "^="; }
@@ -202,6 +175,8 @@
template <typename Type> struct inplace_insert
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_insert<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ insert(object,operand); }
@@ -215,6 +190,8 @@
template <typename Type> struct inplace_erase
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_erase<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ erase(object,operand); }
@@ -228,6 +205,8 @@
template <typename Type> struct inplace_star
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_star<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ object *= operand; }
@@ -241,6 +220,8 @@
template <typename Type> struct inplace_slash
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_slash<Type> type;
+
void operator()(Type& object, const Type& operand)const
{ object /= operand; }
@@ -254,6 +235,8 @@
template <typename Type> struct inplace_max
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_max<Type> type;
+
void operator()(Type& object, const Type& operand)const
{
if(object < operand)
@@ -270,6 +253,8 @@
template <typename Type> struct inplace_min
: public neutron_based_inplace_combine<Type>
{
+ typedef inplace_min<Type> type;
+
void operator()(Type& object, const Type& operand)const
{
if(object > operand)
@@ -283,6 +268,25 @@
inline std::string unary_template_to_string<inplace_min>::apply() { return "min="; }
//--------------------------------------------------------------------------
+ // Inter_section functor
+ //--------------------------------------------------------------------------
+ template<class Type> struct inter_section
+ : public neutron_based_inplace_combine<Type>
+ {
+ typedef typename boost::mpl::
+ if_<is_set<Type>,
+ itl::inplace_et<Type>,
+ itl::inplace_plus<Type>
+ >::type
+ type;
+
+ void operator()(Type& object, const Type& operand)const
+ {
+ type()(object, operand);
+ }
+ };
+
+ //--------------------------------------------------------------------------
// Inverse functor
//--------------------------------------------------------------------------
template<class Functor> struct inverse;
@@ -337,6 +341,27 @@
//--------------------------------------------------------------------------
+ // Inverse inter_section functor
+ //--------------------------------------------------------------------------
+ template<class Type>
+ struct inverse<itl::inter_section<Type> >
+ : public neutron_based_inplace_combine<Type>
+ {
+ typedef typename boost::mpl::
+ if_<is_set<Type>,
+ itl::inplace_caret<Type>,
+ itl::inplace_minus<Type>
+ >::type
+ type;
+
+ void operator()(Type& object, const Type& operand)const
+ {
+ type()(object, operand);
+ }
+ };
+
+
+ //--------------------------------------------------------------------------
// Positive or negative functor trait
//--------------------------------------------------------------------------
@@ -440,7 +465,6 @@
}
};
-
}} // namespace itl boost
#endif
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -25,6 +25,7 @@
#include <boost/itl/detail/design_config.hpp>
#include <boost/itl/type_traits/neutron.hpp>
#include <boost/itl/type_traits/unon.hpp>
+#include <boost/itl/type_traits/infinity.hpp>
#include <boost/itl/type_traits/is_continuous.hpp>
#include <boost/itl/type_traits/difference.hpp>
#include <boost/itl/type_traits/size.hpp>
@@ -478,7 +479,7 @@
else if(x.is(itl::closed_bounded) && IntervalT::domain_equal(x.lower(), x.upper()))
return itl::unon<SizeT>::value();
else
- return std::numeric_limits<SizeT>::infinity();
+ return infinity<SizeT>::value();
}
static typename IntervalT::difference_type
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -56,7 +56,7 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
@@ -408,7 +408,8 @@
/** Subtraction of an interval value pair from the map. */
SubType& subtract(const segment_type& interval_value_pair)
{
- if(Traits::is_total && has_inverse<codomain_type>::value)
+ using namespace type_traits;
+ if(ice_and<Traits::is_total, has_inverse<codomain_type>::value>::value)
that()->template add_<inverse_codomain_combine>(interval_value_pair);
else
that()->template subtract_<inverse_codomain_combine>(interval_value_pair);
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -35,7 +35,7 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -87,7 +87,7 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
ITL_ALLOC Alloc = std::allocator
>
class map: private ITL_IMPL_SPACE::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
Modified: sandbox/itl/boost/itl/rational.hpp
==============================================================================
--- sandbox/itl/boost/itl/rational.hpp (original)
+++ sandbox/itl/boost/itl/rational.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -27,6 +27,7 @@
#endif
#include <boost/itl/type_traits/is_continuous.hpp>
+#include <boost/itl/type_traits/has_inverse.hpp>
namespace boost{namespace itl
{
@@ -36,6 +37,14 @@
typedef is_continuous<boost::rational<Integral> > type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
+
+ template<class Integral>
+ struct has_inverse<boost::rational<Integral> >
+ {
+ typedef has_inverse<boost::rational<Integral> > type;
+ BOOST_STATIC_CONSTANT(bool, value = (is_signed<Integral>::value));
+ };
+
}} // namespace itl boost
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -31,7 +31,7 @@
class Traits = itl::partial_absorber,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
- ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, CodomainT),
template<class,ITL_COMPARE>class Interval = itl::interval,
ITL_ALLOC Alloc = std::allocator
>
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -9,6 +9,7 @@
#define BOOST_ITL_TYPE_TRAITS_HAS_INVERSE_HPP_JOFA_090205
#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
namespace boost{ namespace itl
{
@@ -16,7 +17,9 @@
template <class Type> struct has_inverse
{
typedef has_inverse<Type> type;
- BOOST_STATIC_CONSTANT(bool, value = (is_signed<Type>::value));
+ BOOST_STATIC_CONSTANT(bool,
+ value = (type_traits::ice_or<is_signed<Type>::value,
+ is_floating_point<Type>::value>::value));
};
}} // namespace boost itl
Added: sandbox/itl/boost/itl/type_traits/infinity.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/infinity.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -0,0 +1,59 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2010-2010: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_TYPE_TRAITS_INFINITY_HPP_JOFA_100322
+#define BOOST_ITL_TYPE_TRAITS_INFINITY_HPP_JOFA_100322
+
+#include <string>
+#include <boost/itl/type_traits/is_numeric.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost{ namespace itl
+{
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
+ template <class Type> struct numeric_infinity
+ {
+ typedef numeric_infinity type;
+
+ static Type value()
+ {
+ BOOST_CONCEPT_ASSERT((is_numeric<Type>));
+ if(std::numeric_limits<Type>::has_infinity)
+ return std::numeric_limits<Type>::infinity();
+ else
+ return (std::numeric_limits<Type>::max)();
+ }
+ };
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+
+ template <class Type> struct infinity
+ {
+ typedef infinity type;
+
+ static Type value()
+ {
+ return
+ mpl::if_<is_numeric<Type>,
+ numeric_infinity<Type>,
+ neutron<Type> >::type::value();
+ }
+ };
+
+}} // namespace boost itl
+
+#endif
+
+
Added: sandbox/itl/boost/itl/type_traits/is_numeric.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/is_numeric.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -0,0 +1,33 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2010-2010: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_TYPE_TRAITS_IS_NUMERIC_HPP_JOFA_100322
+#define BOOST_ITL_TYPE_TRAITS_IS_NUMERIC_HPP_JOFA_100322
+
+#include <string>
+#include <complex>
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct is_numeric
+ {
+ typedef is_numeric type;
+ BOOST_STATIC_CONSTANT(bool, value = (0 < std::numeric_limits<Type>::digits));
+ };
+
+ template <class Type>
+ struct is_numeric<std::complex<Type> >
+ {
+ typedef is_numeric type;
+ BOOST_STATIC_CONSTANT(bool, value = true);
+ };
+
+}} // namespace boost itl
+
+#endif
+
+
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -49,8 +49,8 @@
_codomainChoice.setSize(CodomainType::CodomainTypes_size);
_codomainChoice.setMaxWeights(100);
- _codomainChoice[CodomainType::Nat] = 0;
- _codomainChoice[CodomainType::Int] = 100;
+ _codomainChoice[CodomainType::Nat] = 100;
+ _codomainChoice[CodomainType::Int] = 0;
_codomainChoice[CodomainType::Double] = 0;
_codomainChoice[CodomainType::set_int] = 0;
setCodomainTypeNames();
@@ -104,30 +104,30 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<int, int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<int, int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double,int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double,int,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<int, int, partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<int, double, partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double, int, total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double, double, total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case itl_map
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<interval_map<double,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<interval_map<double,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<interval_map<int, int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<interval_map<int, int,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<interval_map<double, double, partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<interval_map<double, int, partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<interval_map<int, double, total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<interval_map<int, int, total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<split_interval_map<double,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<split_interval_map<int, int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<split_interval_map<double,int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<split_interval_map<int, int,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<split_interval_map<double, int, partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<split_interval_map<int, double, partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<split_interval_map<double, int, total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<split_interval_map<int, double, total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case split_interval_map
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -103,30 +103,30 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<double,nat,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<double,nat,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<itl::map<int,nat,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<itl::map<int,nat,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<double,double,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<double,nat, partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<itl::map<int, double,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<itl::map<int, nat, total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case itl_map
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<interval_map<int,nat,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<interval_map<int,nat,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<interval_map<double,nat,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<interval_map<double,nat,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<interval_map<int, nat, partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<interval_map<int, double,partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<interval_map<double,nat, total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<interval_map<double,double,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat, partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat, partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<split_interval_map<int, double,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<split_interval_map<double,double,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case split_interval_map
Modified: sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -25,12 +25,21 @@
BOOST_AUTO_TEST_CASE
(fastest_itl_total_quantifier_map_check_abelian_monoid_et_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_4, int, total_absorber, INTERVAL_MAP>();}
+{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_4, float, total_absorber, INTERVAL_MAP>();}
// (0-x) + x = 0 | total absorber
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_types)
+(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_discrete_codomain)
{ quantifier_map_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, int, total_absorber, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE
+(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_1)
+{ quantifier_map_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, double, total_absorber, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE
+(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_2)
+{ quantifier_map_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, boost::rational<int>, total_absorber, INTERVAL_MAP>();}
+
//------------------------------------------------------------------------------
// total_enricher
//------------------------------------------------------------------------------
@@ -48,13 +57,21 @@
BOOST_AUTO_TEST_CASE
(fastest_itl_total_enricher_quantifier_map_check_abelian_monoid_et_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, int, total_enricher, INTERVAL_MAP>();}
+{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, double, total_enricher, INTERVAL_MAP>();}
// (0-x) + x =p= 0 | total absorber
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types)
+(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_discrete_codomain)
{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, total_enricher, INTERVAL_MAP>();}
+BOOST_AUTO_TEST_CASE
+(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_continuous_codomain_1)
+{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_3, float, total_enricher, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE
+(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_continuous_codomain_2)
+{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_4, boost::rational<int>, total_enricher, INTERVAL_MAP>();}
+
// absorber enricher
// partial x - x == 0 x - x =p= 0 partiality of subtraction
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -59,9 +59,23 @@
cout << map_a << endl;
}
+#include <limits>
+#include <complex>
BOOST_AUTO_TEST_CASE(casual)
{
- ;
+ cout << "--- limits ---\n";
+ cout << "max<char> = " << (std::numeric_limits<char>::max)() << endl;
+ cout << "max<char> = " << static_cast<int>((std::numeric_limits<char>::max)()) << endl;
+ cout << "-----------------------------------\n";
+ cout << "digits<char> = " << std::numeric_limits<char>::digits << endl;
+ cout << "digits<short> = " << std::numeric_limits<short>::digits << endl;
+ cout << "digits<float> = " << std::numeric_limits<float>::digits << endl;
+ cout << "digits<double> = " << std::numeric_limits<double>::digits << endl;
+ cout << "digits<complex<double>> = " << std::numeric_limits<std::complex<double> >::digits << endl;
+ cout << "digits<string> = " << std::numeric_limits<std::string>::digits << endl;
+
+
+ BOOST_CHECK_EQUAL(0 != itl::infinity<int>::value(), true);
}
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -24,7 +24,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -43,7 +43,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -12,7 +12,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -161,7 +161,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -224,7 +224,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -277,7 +277,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -310,7 +310,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -352,8 +352,8 @@
is_123_5 += typename IntervalMapT::value_type(interval<T>::open(v1,v3),u1);
//USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
- BOOST_CHECK_EQUAL( is_123_5.cardinality(), std::numeric_limits<size_T>::infinity() );
- BOOST_CHECK_EQUAL( is_123_5.size(), std::numeric_limits<size_T>::infinity() );
+ BOOST_CHECK_EQUAL( is_123_5.cardinality(), itl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
BOOST_CHECK_EQUAL( is_123_5.length(), d2 );
}
@@ -362,7 +362,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -415,7 +415,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -457,7 +457,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -497,7 +497,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -539,7 +539,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -645,7 +645,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -762,7 +762,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -846,7 +846,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -872,7 +872,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -899,7 +899,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -928,7 +928,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -980,7 +980,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1029,7 +1029,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1068,7 +1068,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1100,7 +1100,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap,
@@ -1127,7 +1127,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -1198,7 +1198,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -1239,7 +1239,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -17,7 +17,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -44,7 +44,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -74,7 +74,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -101,7 +101,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -131,7 +131,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -160,7 +160,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -193,7 +193,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -215,20 +215,23 @@
}
//------------------------------------------------------------------------------
-// (0 - x) + x =p= 0 |
+// (0 - x) + x =p= 0
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
void quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
+ // check abelian group wrt. + and inverability wrt. protonic equality =p= :
+ // (1) (IntervalMapT, +) is an abelian group and
+ // (2) The inverability law: (0 - x) + x =p= 0 holds.
typedef IntervalMap<T,U,Trt> IntervalMapT;
IntervalMapT map_a, map_b, map_c;
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -292,8 +292,8 @@
is_123_5 = is_1_3_5;
is_123_5 += interval<T>::open(v1,v3);
- BOOST_CHECK_EQUAL( is_123_5.cardinality(), std::numeric_limits<size_T>::infinity() );
- BOOST_CHECK_EQUAL( is_123_5.size(), std::numeric_limits<size_T>::infinity() );
+ BOOST_CHECK_EQUAL( is_123_5.cardinality(), itl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
BOOST_CHECK_EQUAL( is_123_5.length(), d2 );
}
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -14,7 +14,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -47,7 +47,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -17,7 +17,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -50,7 +50,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -86,7 +86,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -119,7 +119,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -155,7 +155,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -190,7 +190,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -229,7 +229,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -264,7 +264,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -17,7 +17,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -44,7 +44,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -74,7 +74,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -101,7 +101,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -131,7 +131,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -160,7 +160,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -193,7 +193,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
@@ -222,7 +222,7 @@
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::inplace_et, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
template<class,ITL_COMPARE>class Interval = interval,
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
Modified: sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -17,7 +17,7 @@
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_total_quantifier_map_check_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, total_absorber, INTERVAL_MAP>();}
+{ quantifier_map_check_monoid_et_4_bicremental_types<T, double, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_total_quantifier_map_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
@@ -29,8 +29,17 @@
// (0-x) + x = 0 | total absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_types, T, bicremental_types)
+(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, int, total_absorber, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE
+(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_1, T, bicremental_types)
+{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, float, total_absorber, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE
+(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_2, T, bicremental_types)
+{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, boost::rational<int>, total_absorber, INTERVAL_MAP>();}
+
//------------------------------------------------------------------------------
// total_enricher
//------------------------------------------------------------------------------
@@ -48,13 +57,21 @@
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_total_enricher_quantifier_map_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
+{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, float, total_enricher, INTERVAL_MAP>();}
// (0-x) + x =p= 0 | total absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types, T, bicremental_types)
+(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
+BOOST_AUTO_TEST_CASE_TEMPLATE
+(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_continuous_codomain_1, T, bicremental_types)
+{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<T, double, total_enricher, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE
+(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_continuous_codomain_2, T, bicremental_types)
+{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<T, boost::rational<int>, total_enricher, INTERVAL_MAP>();}
+
// absorber enricher
// partial x - x == 0 x - x =p= 0 partiality of subtraction
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -26,6 +26,7 @@
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
GentorProfileSgl::it()->set_std_profile(16,1);
+ GentorProfileSgl::it()->set_range_double(-1.0, 1.0);
GentorProfileSgl::it()->report_profile();
validater.validate();
};
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-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -66,9 +66,12 @@
//typedef Antisymmetry<itl::map<int,int>, std::less_equal, std_equal> TestLawT;
- typedef JointInverseExistence
- <interval_map<int,int,partial_enricher>, itl::inplace_plus, itl::inplace_minus> TestLawT;
+ //typedef JointInverseExistence
+ // <interval_map<int,int,partial_enricher>, itl::inplace_plus, itl::inplace_minus> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ typedef InplaceSymmetricDifference
+ <interval_map<int,double,total_absorber> > TestLawT;
LawValidater<TestLawT, RandomGentor> test_law;
//-----------------------------------------------------------------------------
Modified: sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/vc9_labat_unsigned_quantifier.vcproj
==============================================================================
--- sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/vc9_labat_unsigned_quantifier.vcproj (original)
+++ sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/vc9_labat_unsigned_quantifier.vcproj 2010-03-23 08:08:38 EDT (Tue, 23 Mar 2010)
@@ -228,6 +228,10 @@
>
</File>
<File
+ RelativePath="..\..\..\..\boost\validate\driver\unsigned_quantifier_driver.hpp"
+ >
+ </File>
+ <File
RelativePath="..\..\..\..\boost\validate\unsigned_quantifier_validater.hpp"
>
</File>
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