[Boost-commit] svn:boost r55408 - in sandbox/itl: boost/itl boost/itl/type_traits libs/itl/test/test_casual_

Subject: [Boost-commit] svn:boost r55408 - in sandbox/itl: boost/itl boost/itl/type_traits libs/itl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2009-08-04 16:31:06

Author: jofaber
Date: 2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
New Revision: 55408
URL: http://svn.boost.org/trac/boost/changeset/55408

Log:
Refactoring: Changed meta predicates of file is_combinable. Stable {msvc-9.0} 
Text files modified: 
   sandbox/itl/boost/itl/functions.hpp                    |    60 ---                                     
   sandbox/itl/boost/itl/interval_base_map.hpp            |     4                                         
   sandbox/itl/boost/itl/interval_base_set.hpp            |     1                                         
   sandbox/itl/boost/itl/map.hpp                          |     5                                         
   sandbox/itl/boost/itl/type_traits/is_combinable.hpp    |   347 ++++++++++++++---------                 
   sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp |   566 ++++++++++++++++++++++++++++++--------- 
   6 files changed, 654 insertions(+), 329 deletions(-)

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp	(original)
+++ sandbox/itl/boost/itl/functions.hpp	2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
@@ -68,7 +68,7 @@
     return object; 
 }
 
-/** \par \b Requires: \c OperandT is an addable derivative type of \c ObjectT. 
+/* \par \b Requires: \c OperandT is an addable derivative type of \c ObjectT. 
         \b Effects: \c operand is added to \c object.
         \par \b Returns: A reference to \c object.
         \b Complexity:
@@ -84,8 +84,8 @@
 n = object.interval_count()
 \endcode
 
-For the addition of \b elements, \b segments and \b interval \b containers
-complexity is \b logarithmic and \b linear respectively.
+For the addition of \b elements or \b segments
+complexity is \b logarithmic or \b linear respectively.
 For \c interval_sets and \c separate_interval_sets addition of segments
 is \b amortized \b logarithmic.
 */
@@ -123,6 +123,7 @@
 //------------------------------------------------------------------------------
 //- Addition |=, | 
 //------------------------------------------------------------------------------
+
 /** \par \b Requires: Types \c ObjectT and \c OperandT are addable.
         \par \b Effects: \c operand is added to \c object.
         \par \b Returns: A reference to \c object.
@@ -182,6 +183,7 @@
 //------------------------------------------------------------------------------
 //- Subtraction -=, -
 //------------------------------------------------------------------------------
+
 /** \par \b Requires: Types \c ObjectT and \c OperandT are subtractable.
         \par \b Effects: \c operand is subtracted from \c object.
         \par \b Returns: A reference to \c object.
@@ -232,25 +234,15 @@
         return object.erase(operand); 
 }
 
-template 
-<
-    class ObjectT, class SetT, class DomainT, ITL_COMPARE Compare, 
-	template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
->
-inline
-typename boost::enable_if<is_interval_set_companion<ObjectT, SetT>,
+template<class ObjectT, class IntervalSetT>
+typename boost::enable_if<combines_right_to_interval_set<ObjectT, IntervalSetT>,
                           ObjectT>::type&
-operator -=
-(
-          ObjectT& object,
-    const interval_base_set<SetT,DomainT,Compare,Interval,Alloc>& operand
-)
+operator -= (ObjectT& object, const IntervalSetT& operand)
 {
         return erase(object, operand);
 }
 
 
-
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_right_inter_combinable<ObjectT, OperandT>, ObjectT>::type
 operator - (ObjectT object, const OperandT& operand)
@@ -277,41 +269,9 @@
 //==============================================================================
 //= Erasure
 //==============================================================================
-template 
-<
-    class ObjectT, class SetT, class DomainT, ITL_COMPARE Compare, 
-	template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
->
-inline
-typename boost::enable_if<is_interval_set_companion<ObjectT, SetT>,
-                          ObjectT>::type&
-erase
-(
-          ObjectT& object,
-    const interval_base_set<SetT,DomainT,Compare,Interval,Alloc>& operand
-)
-{
-    typedef interval_base_set<SetT,DomainT,Compare,Interval,Alloc> operand_type;
-
-    if(operand.empty())
-        return object;
-
-    typename operand_type::const_iterator common_lwb;
-    typename operand_type::const_iterator common_upb;
-
-    if(!Set::common_range(common_lwb, common_upb, operand, object))
-        return object;
-
-    typename operand_type::const_iterator it_ = common_lwb;
-    while(it_ != common_upb)
-		object.erase(*it_++);
-
-    return object; 
-}
-
-
 template<class ObjectT, class OperandT>
-typename boost::enable_if<is_interval_map<ObjectT>, ObjectT>::type& 
+typename boost::enable_if<combines_right_to_interval_container<ObjectT, OperandT>,
+                          ObjectT>::type&
 erase(ObjectT& object, const OperandT& operand)
 {
     if(operand.empty())

Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp	(original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp	2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
@@ -150,12 +150,14 @@
     typedef typename ImplMapT::reverse_iterator reverse_iterator;
     /// const_iterator for iteration over intervals
     typedef typename ImplMapT::const_reverse_iterator const_reverse_iterator;
+
     
 public:
     inline static bool has_symmetric_difference() 
     { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }
 
-    enum{ is_itl_container = true };
+    enum { is_itl_container = true };
+	enum { fineness = 0 };
 
 public:
     //==========================================================================

Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp	(original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp	2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
@@ -116,6 +116,7 @@
     /// const_iterator for iteration over intervals
     typedef typename ImplSetT::const_reverse_iterator const_reverse_iterator;
 
+	enum { fineness = 4 }; //SubType::fineness };
 
 public:
     //==========================================================================

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp	(original)
+++ sandbox/itl/boost/itl/map.hpp	2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
@@ -803,7 +803,10 @@
 inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
 operator &= (      itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
     const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
-{ Map::intersect(object, operand); return object; }
+{ 
+	Map::intersect(object, operand); 
+	return object; 
+}
 
 
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>

Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp	(original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp	2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
@@ -50,24 +50,87 @@
         mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >::value;
 };
 
+//------------------------------------------------------------------------------
+template<class LeftT, class RightT>
+struct is_codomain_equal
+{
+	typedef is_codomain_equal<LeftT, RightT> type;
+	static const bool value =
+		is_same<LeftT::codomain_type, RightT::codomain_type>::value;
+};
+
+template<class LeftT, class RightT>
+struct is_content_type_equal
+{
+	typedef is_content_type_equal<LeftT, RightT> type;
+	static const bool value =
+		mpl::and_<is_domain_compare_equal<LeftT, RightT>, 
+		          is_codomain_equal<LeftT, RightT> >::value;//JODO
+};
+
+//NOTE: Equality of compare order implies the equality of the domain_types
+template<class LeftT, class RightT>
+struct is_domain_compare_equal
+{
+	typedef is_domain_compare_equal<LeftT, RightT> type;
+	static const bool value =
+		is_same<LeftT::domain_compare, RightT::domain_compare>::value;
+};
+
+
+// For equal containers concepts, domain order and codomain type must match.
+template<template<class>class IsConcept, class LeftT, class RightT>
+struct is_concept_compatible
+{
+	typedef is_concept_compatible<IsConcept, LeftT, RightT> type;
+	static const bool value =
+		mpl::and_
+		<
+		    mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >
+		  , is_content_type_equal<LeftT, RightT>
+		>::value;
+};
+
+template<template<class>class LeftConcept, 
+         template<class>class RightConcept,         
+		 class LeftT, class RightT>
+struct is_concept_combinable
+{
+	typedef is_concept_combinable<LeftConcept, RightConcept, LeftT, RightT> type;
+	static const bool value =
+		mpl::and_
+		<
+		    mpl::and_<LeftConcept<LeftT>, RightConcept<RightT> >
+		  , is_domain_compare_equal<LeftT, RightT>
+		>::value;
+};
+
 template<class LeftT, class RightT>
 struct is_intra_combinable
 {
         typedef is_intra_combinable<LeftT, RightT> type;
         static const bool value =
-		mpl::or_<is_concept_equivalent<is_interval_set, LeftT, RightT>, 
-		         is_concept_equivalent<is_interval_map, LeftT, RightT> >::value;
+		mpl::or_
+		<
+			is_concept_compatible<is_interval_set, LeftT, RightT>
+		  , is_concept_compatible<is_interval_map, LeftT, RightT>
+		>::value;
 };
 
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
 template<class LeftT, class RightT>
 struct is_cross_combinable
 {
         typedef is_cross_combinable<LeftT, RightT> type;
         static const bool value =
-		mpl::or_<
-					mpl::and_<is_interval_map<LeftT>, is_interval_set<RightT> >
-				  , mpl::and_<is_interval_set<LeftT>, is_interval_map<RightT> >
-				>::value;
+		mpl::or_
+		<
+			is_concept_combinable<is_interval_set, is_interval_map, LeftT, RightT>
+		  , is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>
+		>::value;
 };
 
 template<class LeftT, class RightT>
@@ -75,7 +138,8 @@
 {
         typedef is_inter_combinable<LeftT, RightT> type;
         static const bool value =
-		mpl::or_<is_intra_combinable<LeftT,RightT>, is_cross_combinable<LeftT,RightT> >::value;
+		mpl::or_<is_intra_combinable<LeftT,RightT>, 
+		         is_cross_combinable<LeftT,RightT> >::value;
 };
 
 //------------------------------------------------------------------------------
@@ -180,6 +244,122 @@
 		>::value;
 };
 
+//------------------------------------------------------------------------------
+//- new right
+//------------------------------------------------------------------------------
+
+template<class GuideT, class CompanionT>
+struct is_interval_set_right_combinable
+{
+    typedef is_interval_set_right_combinable<GuideT, CompanionT> type;
+    static const bool value = 
+		mpl::and_
+		<
+		    is_interval_set<GuideT>
+		  ,	mpl::or_
+			<
+				is_interval_set_derivative<GuideT, CompanionT> 
+			  , is_concept_compatible<is_interval_set, GuideT, CompanionT>
+			>
+		>::value;
+};
+
+template<class GuideT, class CompanionT>
+struct is_interval_map_right_intra_combinable
+{
+    typedef is_interval_map_right_intra_combinable<GuideT, CompanionT> type;
+    static const bool value = 
+		mpl::and_
+		<
+		    is_interval_map<GuideT>
+		  ,	mpl::or_
+			<
+				is_interval_map_derivative<GuideT, CompanionT> 
+			  , is_concept_compatible<is_interval_map, GuideT, CompanionT>
+			>
+		>::value;
+};
+
+template<class GuideT, class CompanionT>
+struct is_interval_map_right_cross_combinable
+{
+    typedef is_interval_map_right_cross_combinable<GuideT, CompanionT> type;
+    static const bool value = 
+		mpl::and_
+		<
+		    is_interval_map<GuideT>
+		  ,	mpl::or_
+			<
+				is_cross_derivative<GuideT, CompanionT> 
+			  , is_concept_combinable<is_interval_map, is_interval_set, GuideT, CompanionT>
+			>
+		>::value;
+};
+
+template<class GuideT, class CompanionT>
+struct is_interval_map_right_inter_combinable
+{
+    typedef is_interval_map_right_inter_combinable<GuideT, CompanionT> type;
+    static const bool value = 
+	    mpl::or_
+		<
+			is_interval_map_right_intra_combinable<GuideT, CompanionT> 
+		  , is_interval_map_right_cross_combinable<GuideT, CompanionT> 
+		>::value;
+};
+
+
+template<class GuideT, class CompanionT>
+struct is_right_intra_combinable
+{
+    typedef is_right_intra_combinable<GuideT, CompanionT> type;
+    static const bool value = 
+	    mpl::or_
+		<
+			is_interval_set_right_combinable<GuideT, CompanionT> 
+		  , is_interval_map_right_intra_combinable<GuideT, CompanionT> 
+		>::value;
+};
+
+template<class GuideT, class CompanionT>
+struct is_right_inter_combinable
+{
+    typedef is_right_inter_combinable<GuideT, CompanionT> type;
+    static const bool value = 
+	    mpl::or_
+		<
+			is_interval_set_right_combinable<GuideT, CompanionT> 
+		  , is_interval_map_right_inter_combinable<GuideT, CompanionT> 
+		>::value;
+};
+
+template<class GuideT, class IntervalSetT>
+struct combines_right_to_interval_set
+{
+    typedef combines_right_to_interval_set<GuideT, IntervalSetT> type;
+    static const bool value = 
+		is_concept_combinable<is_interval_container, is_interval_set, 
+		                      GuideT, IntervalSetT>::value;
+};
+
+template<class GuideT, class IntervalMapT>
+struct combines_right_to_interval_map
+{
+    typedef combines_right_to_interval_map<GuideT, IntervalMapT> type;
+    static const bool value = 
+		is_concept_compatible<is_interval_map, GuideT, IntervalMapT>::value;
+};
+
+template<class GuideT, class IntervalContainerT>
+struct combines_right_to_interval_container
+{
+    typedef combines_right_to_interval_container<GuideT, IntervalContainerT> type;
+    static const bool value = 
+		mpl::or_<combines_right_to_interval_set<GuideT, IntervalContainerT>,
+		         combines_right_to_interval_map<GuideT, IntervalContainerT> >::value;
+};
+
+
 
 //------------------------------------------------------------------------------
 //- segmentational_fineness
@@ -207,88 +387,40 @@
 };
 
 
-
 //------------------------------------------------------------------------------
 // is_interval_set_companion
 //------------------------------------------------------------------------------
-template<class GuideT, class CompanionT> struct is_interval_set_companion;
-
-template
-<
-    class Dom, ITL_COMPARE Cmp, template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
-    template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet1,
-    template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet2
->
-struct is_interval_set_companion<IntervalSet1<Dom,Cmp,Itv,Alc>, 
-                                 IntervalSet2<Dom,Cmp,Itv,Alc> >
-{
-    typedef IntervalSet1<Dom,Cmp,Itv,Alc> GuideT;
-    typedef IntervalSet2<Dom,Cmp,Itv,Alc> CompanionT;
-    typedef is_interval_set_companion<GuideT,CompanionT> type;
-
-    static const bool value = true;
-};
-
-// Every IntervalSet can be a companion of every IntervalMap for 
-// operations intersection and erase.
-template
-<
-    class Dom, class Cod, class Trt, ITL_COMPARE Cmp, ITL_COMBINE Cmb, ITL_SECTION Sec, 
-    template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
-    template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION,
-             template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap,
-    template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
->
-struct is_interval_set_companion<IntervalMap<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc>, 
-                                 IntervalSet<Dom,        Cmp,        Itv,Alc> >
-{ 
-    typedef IntervalMap<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> GuideT;
-    typedef IntervalSet<Dom,        Cmp,        Itv,Alc> CompanionT;
-    typedef is_interval_set_companion<GuideT,CompanionT> type;
-
-    static const bool value = true;
-};
 
+// CompanionT is either an interval_set or a derivative of set level: 
+// element_type=domain_type, segment_type=interval_type
 template<class GuideT, class CompanionT> struct is_interval_set_companion
 { 
     typedef is_interval_set_companion<GuideT,CompanionT> type;
-    enum{ value = is_interval_set_derivative<GuideT,CompanionT>::value }; 
+    static const bool value = 
+		mpl::or_
+		<
+            combines_right_to_interval_set<GuideT,CompanionT>
+          , is_interval_set_derivative<GuideT,CompanionT>
+		>::value;
 };
 
 
 //------------------------------------------------------------------------------
 // is_interval_map_companion
 //------------------------------------------------------------------------------
-template<class GuideT, class CompanionT> struct is_interval_map_companion;
-
-template
-<
-    class Dom, class Cod, class Trt, ITL_COMPARE Cmp, ITL_COMBINE Cmb, ITL_SECTION Sec, 
-    template<class,ITL_COMPARE>class Itv, ITL_ALLOC Alc,
-    template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION,
-             template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap1,
-    template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION,
-             template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalMap2
->
-struct is_interval_map_companion<IntervalMap1<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc>, 
-                                 IntervalMap2<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> >
-{
-    typedef IntervalMap1<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> GuideT;
-    typedef IntervalMap2<Dom,Cod,Trt,Cmp,Cmb,Sec,Itv,Alc> CompanionT;
-    typedef is_interval_map_companion<GuideT,CompanionT> type;
-
-    static const bool value = true;
-};
 
 template<class GuideT, class CompanionT> struct is_interval_map_companion
 { 
     typedef is_interval_map_companion<GuideT,CompanionT> type;
-    enum{ value = is_interval_map_derivative<GuideT,CompanionT>::value }; 
+    static const bool value = 
+		mpl::or_
+		<
+            combines_right_to_interval_map<GuideT,CompanionT>
+          , is_interval_map_derivative<GuideT,CompanionT>
+		>::value;
 };
 
 
-
-
 //------------------------------------------------------------------------------
 //- is_coarser_interval_{set,map}_companion
 //------------------------------------------------------------------------------
@@ -312,67 +444,6 @@
             > segmentational_fineness<CompanionT>::value);
 };
 
-
-
-//------------------------------------------------------------------------------
-// is_right_interval_{set,map}_combinable
-//------------------------------------------------------------------------------
-template<class GuideT, class CompanionT>
-struct is_right_interval_set_combinable
-{ 
-    typedef is_right_interval_set_combinable<GuideT,CompanionT> type;
-    enum{ value = mpl::and_<  is_interval_set<GuideT>
-                            , is_interval_set_companion<GuideT, CompanionT> 
-                           >::value
-        }; 
-};
-
-template<class GuideT, class CompanionT>
-struct is_right_interval_map_combinable
-{ 
-    typedef is_right_interval_map_combinable<GuideT,CompanionT> type;
-    enum{ value = mpl::and_<  is_interval_map<GuideT>
-                            , is_interval_map_companion<GuideT, CompanionT> 
-                           >::value
-        }; 
-};
-
-template<class GuideT, class CompanionT>
-struct is_right_intra_combinable
-{ 
-    typedef is_right_intra_combinable<GuideT,CompanionT> type;
-    static const bool value =
-        mpl::or_<is_right_interval_set_combinable<GuideT, CompanionT>,
-                 is_right_interval_map_combinable<GuideT, CompanionT> 
-                >::value;
-};
-
-template<class GuideT, class CompanionT>
-struct is_right_cross_combinable
-{ 
-    typedef is_right_cross_combinable<GuideT,CompanionT> type;
-    static const bool value =
-        mpl::and_
-        <     is_interval_map<GuideT>
-            , mpl::or_<  is_interval_map_companion<GuideT, CompanionT>
-                       , is_interval_set_companion<GuideT, CompanionT> > 
-        >::value;
-};
-
-template<class GuideT, class CompanionT>
-struct is_right_inter_combinable
-{ 
-    typedef is_right_inter_combinable<GuideT,CompanionT> type;
-    static const bool value =
-        mpl::or_
-        <     
-            mpl::and_<is_interval_map<GuideT>, 
-                      is_right_cross_combinable<GuideT, CompanionT> >
-          , mpl::and_<is_interval_set<GuideT>, 
-                      is_right_intra_combinable<GuideT, CompanionT> >
-        >::value;
-};
-
 //------------------------------------------------------------------------------
 // is_binary_interval_{set,map}_combinable
 //------------------------------------------------------------------------------
@@ -380,20 +451,20 @@
 struct is_binary_interval_set_combinable
 { 
     typedef is_binary_interval_set_combinable<GuideT,CompanionT> type;
-    enum{ value = mpl::and_<  is_interval_set<GuideT>
-                            , is_coarser_interval_set_companion<GuideT, CompanionT> 
-                           >::value
-        }; 
+	static const int value =
+        mpl::and_<  is_interval_set<GuideT>
+                  , is_coarser_interval_set_companion<GuideT, CompanionT> 
+                 >::value;
 };
 
 template<class GuideT, class CompanionT>
 struct is_binary_interval_map_combinable
 { 
     typedef is_binary_interval_map_combinable<GuideT,CompanionT> type;
-    enum{ value = mpl::and_<  is_interval_map<GuideT>
-                            , is_coarser_interval_map_companion<GuideT, CompanionT> 
-                           >::value
-        }; 
+	static const int value =
+        mpl::and_<  is_interval_map<GuideT>
+                  , is_coarser_interval_map_companion<GuideT, CompanionT> 
+                 >::value;
 };
 
 template<class GuideT, class CompanionT>

Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp	(original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp	2009-08-04 16:31:05 EDT (Tue, 04 Aug 2009)
@@ -27,28 +27,183 @@
 using namespace unit_test;
 using namespace boost::itl;
 
-/*CL
-template<template<class, class>class IsCombinable,
-         class LeftT, class RightT>
-void check_combinable(bool truth)
-{
-	bool is_combinable = IsCombinable<LeftT,RightT>::value;
-	BOOST_CHECK_EQUAL(is_combinable, truth);
-}
-*/
 
 template<template<class, class>class IsCombinable,
          class LeftT, class RightT>
-void check_combinable(bool truth, const char* type_combi)
+void check_combinable(bool expected, const char* type_combi, const char* combi_text)
 {
         std::string type_combination = type_combi;
+	std::string is_combi_text = combi_text;
         bool is_combinable = IsCombinable<LeftT,RightT>::value;
         std::string combination_result = is_combinable 
-		? (is_combinable == truth ? type_combination : "NOT combinable: "+type_combination)
-		: (is_combinable == truth ? type_combination : "IS combinable: "+type_combination);
+		? (is_combinable == expected ? type_combination : "expected: NOT "+is_combi_text+"<"+type_combination+">")
+		: (is_combinable == expected ? type_combination : "expected:  IS "+is_combi_text+"<"+type_combination+">");
+
+	//BOOST_CHECK_EQUAL(expected, is_combinable);
         BOOST_CHECK_EQUAL(type_combination, combination_result);
 }
 
+template<template<class, class>class IsCombinable>
+void check_combine_pattern(const char* text,
+	bool jS_e, bool jS_i, bool jS_b, bool jS_p, bool jS_jS, bool jS_zS, bool jS_sS, bool jS_jM, bool jS_sM, 
+	bool zS_e, bool zS_i, bool zS_b, bool zS_p, bool zS_jS, bool zS_zS, bool zS_sS, bool zS_jM, bool zS_sM, 
+	bool sS_e, bool sS_i, bool sS_b, bool sS_p, bool sS_jS, bool sS_zS, bool sS_sS, bool sS_jM, bool sS_sM, 
+	bool jM_e, bool jM_i, bool jM_b, bool jM_p, bool jM_jS, bool jM_zS, bool jM_sS, bool jM_jM, bool jM_sM, 
+	bool sM_e, bool sM_i, bool sM_b, bool sM_p, bool sM_jS, bool sM_zS, bool sM_sS, bool sM_jM, bool sM_sM,
+	bool check_base_class = true
+	)
+{
+	typedef interval_set<int>                jS;
+	typedef separate_interval_set<int>       zS;
+	typedef split_interval_set<int>          sS;
+	typedef interval_map<int,double>         jM;
+	typedef split_interval_map<int,double>   sM;
+
+	typedef interval_base_set<jS,int>        jT;
+	typedef interval_base_set<zS,int>        zT;
+	typedef interval_base_set<sS,int>        sT;
+	typedef interval_base_map<jM,int,double> jN;
+	typedef interval_base_map<sM,int,double> sN;
+
+	typedef interval_set<int>::element_type  S_e;
+	typedef interval_set<int>::segment_type  S_i;
+
+	typedef interval_map<int,double>::element_type M_b;
+	typedef interval_map<int,double>::segment_type M_p;
+
+	//--------------------------------------------------------------------------
+	check_combinable<IsCombinable, jS, S_e>(jS_e , "jS_e ", text);
+	check_combinable<IsCombinable, jS, S_i>(jS_i , "jS_i ", text);
+	check_combinable<IsCombinable, jS, M_b>(jS_b , "jS_b ", text);
+	check_combinable<IsCombinable, jS, M_p>(jS_p , "jS_p ", text);
+	check_combinable<IsCombinable, jS, jS >(jS_jS, "jS_jS", text);
+	check_combinable<IsCombinable, jS, zS >(jS_zS, "jS_zS", text);
+	check_combinable<IsCombinable, jS, sS >(jS_sS, "jS_sS", text);
+	check_combinable<IsCombinable, jS, jM >(jS_jM, "jS_jM", text);
+	check_combinable<IsCombinable, jS, sM >(jS_sM, "jS_sM", text);
+	//--------------------------------------------------------------------------
+	check_combinable<IsCombinable, zS, S_e>(zS_e , "zS_e ", text);
+	check_combinable<IsCombinable, zS, S_i>(zS_i , "zS_i ", text);
+	check_combinable<IsCombinable, zS, M_b>(zS_b , "zS_b ", text);
+	check_combinable<IsCombinable, zS, M_p>(zS_p , "zS_p ", text);
+	check_combinable<IsCombinable, zS, jS >(zS_jS, "zS_jS", text);
+	check_combinable<IsCombinable, zS, zS >(zS_zS, "zS_zS", text);
+	check_combinable<IsCombinable, zS, sS >(zS_sS, "zS_sS", text);
+	check_combinable<IsCombinable, zS, jM >(zS_jM, "zS_jM", text);
+	check_combinable<IsCombinable, zS, sM >(zS_sM, "zS_sM", text);
+	//--------------------------------------------------------------------------
+	check_combinable<IsCombinable, sS, S_e>(sS_e , "sS_e ", text);
+	check_combinable<IsCombinable, sS, S_i>(sS_i , "sS_i ", text);
+	check_combinable<IsCombinable, sS, M_b>(sS_b , "sS_b ", text);
+	check_combinable<IsCombinable, sS, M_p>(sS_p , "sS_p ", text);
+	check_combinable<IsCombinable, sS, jS >(sS_jS, "sS_jS", text);
+	check_combinable<IsCombinable, sS, zS >(sS_zS, "sS_zS", text);
+	check_combinable<IsCombinable, sS, sS >(sS_sS, "sS_sS", text);
+	check_combinable<IsCombinable, sS, jM >(sS_jM, "sS_jM", text);
+	check_combinable<IsCombinable, sS, sM >(sS_sM, "sS_sM", text);
+	//--------------------------------------------------------------------------
+	check_combinable<IsCombinable, jM, S_e>(jM_e , "jM_e ", text);
+	check_combinable<IsCombinable, jM, S_i>(jM_i , "jM_i ", text);
+	check_combinable<IsCombinable, jM, M_b>(jM_b , "jM_b ", text);
+	check_combinable<IsCombinable, jM, M_p>(jM_p , "jM_p ", text);
+	check_combinable<IsCombinable, jM, jS >(jM_jS, "jM_jS", text);
+	check_combinable<IsCombinable, jM, zS >(jM_zS, "jM_zS", text);
+	check_combinable<IsCombinable, jM, sS >(jM_sS, "jM_sS", text);
+	check_combinable<IsCombinable, jM, jM >(jM_jM, "jM_jM", text);
+	check_combinable<IsCombinable, jM, sM >(jM_sM, "jM_sM", text);
+	//--------------------------------------------------------------------------
+	check_combinable<IsCombinable, sM, S_e>(sM_e , "sM_e ", text);
+	check_combinable<IsCombinable, sM, S_i>(sM_i , "sM_i ", text);
+	check_combinable<IsCombinable, sM, M_b>(sM_b , "sM_b ", text);
+	check_combinable<IsCombinable, sM, M_p>(sM_p , "sM_p ", text);
+	check_combinable<IsCombinable, sM, jS >(sM_jS, "sM_jS", text);
+	check_combinable<IsCombinable, sM, zS >(sM_zS, "sM_zS", text);
+	check_combinable<IsCombinable, sM, sS >(sM_sS, "sM_sS", text);
+	check_combinable<IsCombinable, sM, jM >(sM_jM, "sM_jM", text);
+	check_combinable<IsCombinable, sM, sM >(sM_sM, "sM_sM", text);
+	//--------------------------------------------------------------------------
+
+	if(check_base_class)
+	{
+		//--------------------------------------------------------------------------
+		check_combinable<IsCombinable, jT, S_e>(jS_e , "jT_e ", text);
+		check_combinable<IsCombinable, jT, S_i>(jS_i , "jT_i ", text);
+		check_combinable<IsCombinable, jT, M_b>(jS_b , "jT_b ", text);
+		check_combinable<IsCombinable, jT, M_p>(jS_p , "jT_p ", text);
+		check_combinable<IsCombinable, jT, jS >(jS_jS, "jT_jS", text);
+		check_combinable<IsCombinable, jT, zS >(jS_zS, "jT_zS", text);
+		check_combinable<IsCombinable, jT, sS >(jS_sS, "jT_sS", text);
+		check_combinable<IsCombinable, jT, jM >(jS_jM, "jT_jM", text);
+		check_combinable<IsCombinable, jT, sM >(jS_sM, "jT_sM", text);
+		check_combinable<IsCombinable, jT, jT >(jS_jS, "jT_jT", text);
+		check_combinable<IsCombinable, jT, zT >(jS_zS, "jT_zT", text);
+		check_combinable<IsCombinable, jT, sT >(jS_sS, "jT_sT", text);
+		check_combinable<IsCombinable, jT, jN >(jS_jM, "jT_jN", text);
+		check_combinable<IsCombinable, jT, sN >(jS_sM, "jT_sN", text);
+		//--------------------------------------------------------------------------
+		check_combinable<IsCombinable, zT, S_e>(zS_e , "zT_e ", text);
+		check_combinable<IsCombinable, zT, S_i>(zS_i , "zT_i ", text);
+		check_combinable<IsCombinable, zT, M_b>(zS_b , "zT_b ", text);
+		check_combinable<IsCombinable, zT, M_p>(zS_p , "zT_p ", text);
+		check_combinable<IsCombinable, zT, jS >(zS_jS, "zT_jS", text);
+		check_combinable<IsCombinable, zT, zS >(zS_zS, "zT_zS", text);
+		check_combinable<IsCombinable, zT, sS >(zS_sS, "zT_sS", text);
+		check_combinable<IsCombinable, zT, jM >(zS_jM, "zT_jM", text);
+		check_combinable<IsCombinable, zT, sM >(zS_sM, "zT_sM", text);
+		check_combinable<IsCombinable, zT, jT >(zS_jS, "zT_jT", text);
+		check_combinable<IsCombinable, zT, zT >(zS_zS, "zT_zT", text);
+		check_combinable<IsCombinable, zT, sT >(zS_sS, "zT_sT", text);
+		check_combinable<IsCombinable, zT, jN >(zS_jM, "zT_jN", text);
+		check_combinable<IsCombinable, zT, sN >(zS_sM, "zT_sN", text);
+		//--------------------------------------------------------------------------
+		check_combinable<IsCombinable, sT, S_e>(sS_e , "sT_e ", text);
+		check_combinable<IsCombinable, sT, S_i>(sS_i , "sT_i ", text);
+		check_combinable<IsCombinable, sT, M_b>(sS_b , "sT_b ", text);
+		check_combinable<IsCombinable, sT, M_p>(sS_p , "sT_p ", text);
+		check_combinable<IsCombinable, sT, jS >(sS_jS, "sT_jS", text);
+		check_combinable<IsCombinable, sT, zS >(sS_zS, "sT_zS", text);
+		check_combinable<IsCombinable, sT, sS >(sS_sS, "sT_sS", text);
+		check_combinable<IsCombinable, sT, jM >(sS_jM, "sT_jM", text);
+		check_combinable<IsCombinable, sT, sM >(sS_sM, "sT_sM", text);
+		check_combinable<IsCombinable, sT, jT >(sS_jS, "sT_jT", text);
+		check_combinable<IsCombinable, sT, zT >(sS_zS, "sT_zT", text);
+		check_combinable<IsCombinable, sT, sT >(sS_sS, "sT_sT", text);
+		check_combinable<IsCombinable, sT, jN >(sS_jM, "sT_jN", text);
+		check_combinable<IsCombinable, sT, sN >(sS_sM, "sT_sN", text);
+		//--------------------------------------------------------------------------
+		check_combinable<IsCombinable, jN, S_e>(jM_e , "jN_e ", text);
+		check_combinable<IsCombinable, jN, S_i>(jM_i , "jN_i ", text);
+		check_combinable<IsCombinable, jN, M_b>(jM_b , "jN_b ", text);
+		check_combinable<IsCombinable, jN, M_p>(jM_p , "jN_p ", text);
+		check_combinable<IsCombinable, jN, jS >(jM_jS, "jN_jS", text);
+		check_combinable<IsCombinable, jN, zS >(jM_zS, "jN_zS", text);
+		check_combinable<IsCombinable, jN, sS >(jM_sS, "jN_sS", text);
+		check_combinable<IsCombinable, jN, jM >(jM_jM, "jN_jM", text);//
+		check_combinable<IsCombinable, jN, sM >(jM_sM, "jN_sM", text);//
+		check_combinable<IsCombinable, jN, jT >(jM_jS, "jN_jT", text);
+		check_combinable<IsCombinable, jN, zT >(jM_zS, "jN_zT", text);
+		check_combinable<IsCombinable, jN, sT >(jM_sS, "jN_sT", text);
+		check_combinable<IsCombinable, jN, jN >(jM_jM, "jN_jN", text);//
+		check_combinable<IsCombinable, jN, sN >(jM_sM, "jN_sN", text);//
+		//--------------------------------------------------------------------------
+		check_combinable<IsCombinable, sN, S_e>(sM_e , "sN_e ", text);
+		check_combinable<IsCombinable, sN, S_i>(sM_i , "sN_i ", text);
+		check_combinable<IsCombinable, sN, M_b>(sM_b , "sN_b ", text);
+		check_combinable<IsCombinable, sN, M_p>(sM_p , "sN_p ", text);
+		check_combinable<IsCombinable, sN, jS >(sM_jS, "sN_jS", text);
+		check_combinable<IsCombinable, sN, zS >(sM_zS, "sN_zS", text);
+		check_combinable<IsCombinable, sN, sS >(sM_sS, "sN_sS", text);
+		check_combinable<IsCombinable, sN, jM >(sM_jM, "sN_jM", text);
+		check_combinable<IsCombinable, sN, sM >(sM_sM, "sN_sM", text);
+		check_combinable<IsCombinable, sN, jT >(sM_jS, "sN_jT", text);
+		check_combinable<IsCombinable, sN, zT >(sM_zS, "sN_zT", text);
+		check_combinable<IsCombinable, sN, sT >(sM_sS, "sN_sT", text);
+		check_combinable<IsCombinable, sN, jN >(sM_jM, "sN_jN", text);
+		check_combinable<IsCombinable, sN, sN >(sM_sM, "sN_sN", text);
+	}
+}
+
+
 BOOST_AUTO_TEST_CASE(casual_test)
 {
     typedef int T;
@@ -58,163 +213,296 @@
     typedef interval_set<int> IntervalSetT;
     typedef split_interval_set<int> SplitIntervalSetT;
     
-    SplitIntervalMapT map_a, map_b;
-    map_a.add(IDv(8,9,1)).add(IIv(6,11,3));
-	cout << ">>> map_a = " << map_a << endl;
-    map_b.add(IDv(0,9,2)).add(IIv(3,6,1));
-	cout << ">>> map_b = " << map_b << endl;
-
-	SplitIntervalMapT map_a_b = map_a + map_b;
-	SplitIntervalMapT map_b_a = map_b + map_a;
-	cout << ">>> map_a_b = " << map_a_b << endl;
-	cout << ">>> map_b_a = " << map_b_a << endl;
-
-    IntervalSetT set_a;
-	set_a.add(I_D(2,4));
-	map_a -= set_a;
-	SplitIntervalMapT map_c;
-	map_c = map_a - set_a;
-
-	BOOST_CHECK_EQUAL(is_interval_container<interval_set<int> >::value, true);
-	BOOST_CHECK_EQUAL(is_interval_container<split_interval_set<int> >::value, true);
-	BOOST_CHECK_EQUAL(is_interval_container<separate_interval_set<int> >::value, true);
-	BOOST_CHECK_EQUAL(is_interval_container<std::string >::value, false);
-
-	bool interval_set_companion 
-		= is_interval_set_companion< interval_map<int,int>, interval_set<int> >::value;
-	BOOST_CHECK_EQUAL(interval_set_companion, true);
-
         //--------------------------------------------------------------------------
-	bool is_combinable_jS_e
-		= is_intra_derivative<interval_set<int>, interval_set<int>::element_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_jS_e, true);
-
-	bool is_combinable_zS_e
-		= is_intra_derivative<separate_interval_set<int>, interval_set<int>::element_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_zS_e, true);
-
-	bool is_combinable_sS_e
-		= is_intra_derivative<split_interval_set<int>, interval_set<int>::element_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_sS_e, true);
+	// derivative
         //--------------------------------------------------------------------------
-	bool is_combinable_jS_i
-		= is_intra_derivative<interval_set<int>, interval_set<int>::segment_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_jS_i, true);
-
-	bool is_combinable_zS_i
-		= is_intra_derivative<separate_interval_set<int>, interval_set<int>::segment_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_zS_i, true);
+	// 1.1
+    check_combine_pattern<is_intra_derivative>(
+		"is_intra_derivative",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // zS
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
+		0, 0, 1, 1, 0, 0, 0, 0, 0  // sM
+		);
 
-	bool is_combinable_sS_i
-		= is_intra_derivative<split_interval_set<int>, interval_set<int>::segment_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_sS_i, true);
         //--------------------------------------------------------------------------
-	bool is_combinable_jM_e
-		= is_intra_derivative<interval_map<int,int>, interval_map<int,int>::element_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_jM_e, true);
+	// 1.2
+    check_combine_pattern<is_cross_derivative>(
+		"is_cross_derivative",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jM
+		1, 1, 0, 0, 0, 0, 0, 0, 0  // sM
+		);
 
-	bool is_combinable_sM_e
-		= is_intra_derivative<split_interval_map<int,int>, split_interval_map<int,int>::element_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_sM_e, true);
         //--------------------------------------------------------------------------
-	bool is_combinable_jM_i
-		= is_intra_derivative<interval_map<int,int>, interval_map<int,int>::segment_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_jM_i, true);
+	// 1.3
+    check_combine_pattern<is_inter_derivative>(
+		"is_inter_derivative",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // zS
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // sS
+		1, 1, 1, 1, 0, 0, 0, 0, 0, // jM
+		1, 1, 1, 1, 0, 0, 0, 0, 0  // sM
+		);
 
-	bool is_combinable_sM_i
-		= is_intra_derivative<split_interval_map<int,int>, split_interval_map<int,int>::segment_type>::value;
-	BOOST_CHECK_EQUAL(is_combinable_sM_i, true);
         //--------------------------------------------------------------------------
+	// inter interval_container
         //--------------------------------------------------------------------------
+	// 2.1
+    check_combine_pattern<is_intra_combinable>(
+		"is_intra_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // jS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // zS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // sS
+		0, 0, 0, 0, 0, 0, 0, 1, 1, // jM
+		0, 0, 0, 0, 0, 0, 0, 1, 1  // sM
+		);
 
-	typedef interval_set<int>           jS;
-	typedef separate_interval_set<int>  zS;
-	typedef split_interval_set<int>     sS;
-	typedef interval_map<int,int>       jM;
-	typedef split_interval_map<int,int> sM;
-
-	typedef interval_set<int>::element_type            jS_e;
-	typedef separate_interval_set<int>::element_type   zS_e;
-	typedef split_interval_set<int>::element_type      sS_e;
-	typedef interval_map<int,int>::element_type        jM_b;
-	typedef split_interval_map<int,int>::element_type  sM_b;
-
-	typedef interval_set<int>::segment_type            jS_i;
-	typedef separate_interval_set<int>::segment_type   zS_i;
-	typedef split_interval_set<int>::segment_type      sS_i;
-	typedef interval_map<int,int>::segment_type        jM_p;
-	typedef split_interval_map<int,int>::segment_type  sM_p;
-
-	typedef interval_map<int,int>::domain_type         jM_e;
-	typedef split_interval_map<int,int>::domain_type   sM_e;
-	typedef interval_map<int,int>::interval_type       jM_i;
-	typedef split_interval_map<int,int>::interval_type sM_i;
+	//--------------------------------------------------------------------------
+	// 2.2
+    check_combine_pattern<is_cross_combinable>(
+		"is_cross_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 1, 1, // jS
+		0, 0, 0, 0, 0, 0, 0, 1, 1, // zS
+		0, 0, 0, 0, 0, 0, 0, 1, 1, // sS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // jM
+		0, 0, 0, 0, 1, 1, 1, 0, 0  // sM
+		);
 
-	//     
-	// jS
-	// zS
+	//--------------------------------------------------------------------------
+	// 2.3
+    check_combine_pattern<is_inter_combinable>(
+		"is_inter_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 1, 1, 1, 1, 1, // jS
+		0, 0, 0, 0, 1, 1, 1, 1, 1, // zS
+		0, 0, 0, 0, 1, 1, 1, 1, 1, // sS
+		0, 0, 0, 0, 1, 1, 1, 1, 1, // jM
+		0, 0, 0, 0, 1, 1, 1, 1, 1  // sM
+		);
 
+	//--------------------------------------------------------------------------
+	// right
+	//--------------------------------------------------------------------------
+	// 3.1
+    check_combine_pattern<is_interval_set_right_combinable>(
+		"is_interval_set_right_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jM
+		0, 0, 0, 0, 0, 0, 0, 0, 0  // sM
+		);
 
-	check_combinable<is_intra_derivative, jS, jS_e>(true, "jS_jS_e");
-	check_combinable<is_intra_derivative, zS, zS_e>(true, "zS_zS_e");
-	check_combinable<is_intra_derivative, sS, sS_e>(true, "sS_sS_e");
+	//--------------------------------------------------------------------------
+	// 3.2
+    check_combine_pattern<is_interval_map_right_intra_combinable>(
+		"is_interval_map_right_intra_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 1, 1, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 1  // sM
+		);
 
-	check_combinable<is_intra_derivative, jS, jS_i>(true, "jS_jS_i");
-	check_combinable<is_intra_derivative, zS, zS_i>(true, "zS_zS_i");
-	check_combinable<is_intra_derivative, sS, sS_i>(true, "sS_sS_i");
+	//--------------------------------------------------------------------------
+	// 3.3
+    check_combine_pattern<is_interval_map_right_cross_combinable>(
+		"is_interval_map_right_cross_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // jM
+		1, 1, 0, 0, 1, 1, 1, 0, 0  // sM
+		);
 
-	check_combinable<is_intra_derivative, jM, jM_b>(true, "jM_jM_b");
-	check_combinable<is_intra_derivative, sM, sM_b>(true, "sM_sM_b");
+	//--------------------------------------------------------------------------
+	// 3.4
+    check_combine_pattern<is_interval_map_right_inter_combinable>(
+		"is_interval_map_right_inter_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
+		1, 1, 1, 1, 1, 1, 1, 1, 1, // jM
+		1, 1, 1, 1, 1, 1, 1, 1, 1  // sM
+		);
 
-	check_combinable<is_intra_derivative, jM, jM_p>(true, "jM_jM_p");
-	check_combinable<is_intra_derivative, sM, sM_p>(true, "sM_sM_p");
+	//--------------------------------------------------------------------------
+	// 3.5
+    check_combine_pattern<is_right_intra_combinable>(
+		"is_right_intra_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 1, 1, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 1  // sM
+		);
 
-	check_combinable<is_cross_derivative, jM, jM_e>(true, "jM_jM_e");
-	check_combinable<is_cross_derivative, sM, sM_e>(true, "sM_sM_e");
+	//--------------------------------------------------------------------------
+	// 3.6
+    check_combine_pattern<is_right_inter_combinable>(
+		"is_right_inter_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
+		1, 1, 1, 1, 1, 1, 1, 1, 1, // jM
+		1, 1, 1, 1, 1, 1, 1, 1, 1  // sM
+		);
 
-	check_combinable<is_cross_derivative, jM, jM_i>(true, "jM_jM_i");
-	check_combinable<is_cross_derivative, sM, sM_i>(true, "sM_sM_i");
+	//--------------------------------------------------------------------------
+	// 3.7
+    check_combine_pattern<combines_right_to_interval_set>(
+		"combines_right_to_interval_set",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // jS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // zS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // sS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // jM
+		0, 0, 0, 0, 1, 1, 1, 0, 0  // sM
+		);
 
-	check_combinable<is_interval_set_companion, jS, jS>(true, "jS_jS");
-	check_combinable<is_interval_set_companion, jS, zS>(true, "jS_zS");
-	check_combinable<is_interval_set_companion, jS, sS>(true, "jS_sS");
+	//--------------------------------------------------------------------------
+	// 3.8
+    check_combine_pattern<combines_right_to_interval_map>(
+		"combines_right_to_interval_map",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
+		0, 0, 0, 0, 0, 0, 0, 1, 1, // jM
+		0, 0, 0, 0, 0, 0, 0, 1, 1  // sM
+		);
 
-	check_combinable<is_interval_set_companion, zS, jS>(true, "zS_jS");
-	check_combinable<is_interval_set_companion, zS, zS>(true, "zS_zS");
-	check_combinable<is_interval_set_companion, zS, sS>(true, "zS_sS");
+	//--------------------------------------------------------------------------
+	// 3.9
+    check_combine_pattern<combines_right_to_interval_container>(
+		"combines_right_to_interval_container",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // jS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // zS
+		0, 0, 0, 0, 1, 1, 1, 0, 0, // sS
+		0, 0, 0, 0, 1, 1, 1, 1, 1, // jM
+		0, 0, 0, 0, 1, 1, 1, 1, 1  // sM
+		);
 
-	check_combinable<is_interval_set_companion, sS, jS>(true, "sS_jS");
-	check_combinable<is_interval_set_companion, sS, zS>(true, "sS_zS");
-	check_combinable<is_interval_set_companion, sS, sS>(true, "sS_sS");
+	//--------------------------------------------------------------------------
+	// 4.1
+    check_combine_pattern<is_interval_set_companion>(
+		"is_interval_set_companion",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
+		1, 1, 0, 0, 1, 1, 1, 0, 0, // jM
+		1, 1, 0, 0, 1, 1, 1, 0, 0  // sM
+		);
 
-	check_combinable<is_interval_set_companion, jM, jS>(true, "jM_jS");
-	check_combinable<is_interval_set_companion, jM, zS>(true, "jM_zS");
-	check_combinable<is_interval_set_companion, jM, sS>(true, "jM_sS");
+	//--------------------------------------------------------------------------
+	// 4.2 = 3.2 is_interval_map_right_intra_combinable
+    check_combine_pattern<is_interval_map_companion>(
+		"is_interval_map_companion",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 1, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 1, 0, 0, 0, 0, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 1, 1, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 1  // sM
+		);
 
-	check_combinable<is_interval_set_companion, sM, jS>(true, "sM_jS");
-	check_combinable<is_interval_set_companion, sM, zS>(true, "sM_zS");
-	check_combinable<is_interval_set_companion, sM, sS>(true, "sM_sS");
+	//--------------------------------------------------------------------------
+	// 5.1
+    check_combine_pattern<is_coarser_interval_set_companion>(
+		"is_coarser_interval_set_companion",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jM
+		1, 1, 0, 0, 1, 1, 0, 0, 0, // sM
+		false
+		);
 
         //--------------------------------------------------------------------------
-	check_combinable<is_intra_combinable, jS, jS>(true, "jS_jS");
-	check_combinable<is_intra_combinable, zS, jS>(true, "zS_jS");
-	check_combinable<is_intra_combinable, sS, jS>(true, "sS_jS");
+	// 5.2
+    check_combine_pattern<is_coarser_interval_map_companion>(
+		"is_coarser_interval_map_companion",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 1, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 1, 0, 0, 0, 0, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
+		false
+		);
 
-	check_combinable<is_intra_combinable, jS, zS>(true, "jS_zS");
-	check_combinable<is_intra_combinable, zS, zS>(true, "zS_zS");
-	check_combinable<is_intra_combinable, sS, zS>(true, "sS_zS");
+	//--------------------------------------------------------------------------
+	// 6.1
+    check_combine_pattern<is_binary_interval_set_combinable>(
+		"is_binary_interval_set_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jM
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sM
+		false
+		);
 
-	check_combinable<is_intra_combinable, jS, zS>(true, "jS_sS");
-	check_combinable<is_intra_combinable, zS, zS>(true, "zS_sS");
-	check_combinable<is_intra_combinable, sS, zS>(true, "sS_sS");
+	//--------------------------------------------------------------------------
+	// 6.2
+    check_combine_pattern<is_binary_interval_map_combinable>(
+		"is_binary_interval_map_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
+		0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
+		false
+		);
 
-	check_combinable<is_intra_combinable, jM, jM>(true, "jM_jM");
-	check_combinable<is_intra_combinable, sM, jM>(true, "sM_jM");
+	//--------------------------------------------------------------------------
+	// 6.3
+    check_combine_pattern<is_binary_intra_combinable>(
+		"is_binary_intra_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
+		false
+		);
 
-	check_combinable<is_intra_combinable, jM, sM>(true, "jM_sM");
-	check_combinable<is_intra_combinable, sM, sM>(true, "sM_sM");
+	//--------------------------------------------------------------------------
+	// 6.4
+    check_combine_pattern<is_binary_intra_combinable>(
+		"is_binary_intra_combinable",
+	//  e  i  b  p jS zS sS jM sM       
+		1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
+		1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
+		1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
+		0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
+		0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
+		false
+		);
 
         //--------------------------------------------------------------------------
-    BOOST_CHECK_EQUAL(map_a_b, map_b_a);
+	//--------------------------------------------------------------------------
+
 
 }