ceph/src/boost/libs/icl/test/test_laws.hpp

   1 /*-----------------------------------------------------------------------------+
   2 Copyright (c) 2008-2010: Joachim Faulhaber
   3 +------------------------------------------------------------------------------+
   4    Distributed under the Boost Software License, Version 1.0.
   5       (See accompanying file LICENCE.txt or copy at
   6            http://www.boost.org/LICENSE_1_0.txt)
   7 +-----------------------------------------------------------------------------*/
   8 #ifndef BOOST_LIBS_ICL_TEST_ICL_LAWS_HPP_JOFA_090119
   9 #define BOOST_LIBS_ICL_TEST_ICL_LAWS_HPP_JOFA_090119
  10
  11 #include <boost/icl/type_traits/identity_element.hpp>
  12 #include <boost/icl/associative_interval_container.hpp>
  13
  14 namespace boost{namespace icl
  15 {
  16
  17 template<class Type>
  18 struct equality
  19 {
  20     typedef Type first_argument_type;
  21     typedef Type second_argument_type;
  22     typedef bool result_type;
  23     typedef bool (type)(const Type&, const Type&);
  24 };
  25
  26 //------------------------------------------------------------------------------
  27 // Associativity
  28 //------------------------------------------------------------------------------
  29
  30 // The definition of a boost test via a macro, that allows to be instantiated for
  31 // different operator signs 'op_sign'. For every 'op_sign' a separate function
  32 // template is generated by appending the suffic 'op_tag' to the function
  33 // name.
  34 // So this is the function template via macro that checks the law
  35 // associativity for an operator 'op_sign'
  36 #define DEFINE_ASSOCIATIVITY_CHECK_WRT(op_tag, op_sign) \
  37 template<class Type, class TypeB, class TypeC> \
  38 void check_associativity_wrt_##op_tag(const Type& a, const TypeB& b, const TypeC& c) \
  39 { \
  40     Type left  = (a op_sign b) op_sign c; \
  41     Type right = a op_sign (b op_sign c); \
  42     BOOST_CHECK(left==right); \
  43 }
  44
  45 #define DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
  46 template<class Type, class TypeB, class TypeC> \
  47 void check_associativity_wrt_equal_##op_tag \
  48 (typename equality<Type>::type* equal, \
  49 const Type& a, const TypeB& b, const TypeC& c) \
  50 { \
  51     Type left  = (a op_sign b) op_sign c; \
  52     Type right = a op_sign (b op_sign c); \
  53     BOOST_CHECK((*equal)(left,right)); \
  54 }
  55
  56 // Here we define the call of the test function thats definition
  57 // template has been generated by the macro above.
  58 #define CHECK_ASSOCIATIVITY_WRT(op_tag)       check_associativity_wrt_##op_tag
  59 #define CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag) check_associativity_wrt_equal_##op_tag
  60
  61 // Here we actually generate function templates by calling the defining
  62 // macros.
  63 DEFINE_ASSOCIATIVITY_CHECK_WRT      (plus,  + )
  64 DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus,  + )
  65 DEFINE_ASSOCIATIVITY_CHECK_WRT      (pipe,  | )
  66 DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(pipe,  | )
  67 DEFINE_ASSOCIATIVITY_CHECK_WRT      (et,    & )
  68 DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(et,    & )
  69 DEFINE_ASSOCIATIVITY_CHECK_WRT      (caret, ^ )
  70 DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(caret, ^ )
  71
  72
  73 //------------------------------------------------------------------------------
  74 // Neutrality
  75 //------------------------------------------------------------------------------
  76
  77 #define DEFINE_RIGHT_NEUTRALITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
  78 template<class Type> \
  79 void check_right_neutrality_wrt_equal_##op_tag \
  80 (typename equality<Type>::type* equal, const Type& a, const Type& identity_element) \
  81 { \
  82     Type left  = a op_sign identity_element; \
  83     Type right = identity_element; \
  84     BOOST_CHECK((*equal)(left,right)); \
  85 }
  86
  87 #define DEFINE_RIGHT_NEUTRALITY_CHECK_WRT(op_tag, op_sign) \
  88 template<class Type> \
  89 void check_right_neutrality_wrt_##op_tag \
  90 (typename equality<Type>::type* equal, const Type& a, const Type& identity_element) \
  91 { \
  92     Type left  = a op_sign identity_element; \
  93     Type right = identity_element; \
  94     BOOST_CHECK(left==right); \
  95 }
  96
  97 #define DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
  98 template<class Type> \
  99 void check_neutrality_wrt_equal_##op_tag \
 100 (typename equality<Type>::type* equal, const Type& a, const Type& identity_element) \
 101 { \
 102     Type left  = a op_sign identity_element; \
 103     Type right = identity_element op_sign a; \
 104     BOOST_CHECK((*equal)(left,right)); \
 105 }
 106
 107 #define DEFINE_NEUTRALITY_CHECK_WRT(op_tag, op_sign) \
 108 template<class Type> \
 109 void check_neutrality_wrt_##op_tag \
 110 (const Type& a, const Type& identity_element) \
 111 { \
 112     Type left  = a op_sign identity_element; \
 113     Type right = identity_element op_sign a; \
 114     BOOST_CHECK(left==right); \
 115 }
 116
 117 #define CHECK_NEUTRALITY_WRT(op_tag) check_neutrality_wrt_##op_tag
 118 #define CHECK_NEUTRALITY_WRT_EQUAL(op_tag) check_neutrality_wrt_equal_##op_tag
 119
 120 DEFINE_NEUTRALITY_CHECK_WRT      (plus,  + )
 121 DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(plus,  + )
 122 DEFINE_NEUTRALITY_CHECK_WRT      (pipe,  | )
 123 DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(pipe,  | )
 124 DEFINE_NEUTRALITY_CHECK_WRT      (minus, - )
 125 DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(minus, - )
 126 DEFINE_NEUTRALITY_CHECK_WRT      (et,    & )
 127 DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(et,    & )
 128 DEFINE_NEUTRALITY_CHECK_WRT      (caret, ^ )
 129 DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(caret, ^ )
 130
 131 //------------------------------------------------------------------------------
 132 // Commutativity
 133 //------------------------------------------------------------------------------
 134
 135 #define DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
 136 template<class Type, class TypeB> \
 137 void check_commutativity_wrt_equal_##op_tag \
 138 (typename equality<Type>::type* equal, const Type& a, const TypeB& b) \
 139 { \
 140     Type left  = a op_sign b; \
 141     Type right = b op_sign a; \
 142     BOOST_CHECK((*equal)(left,right)); \
 143 }
 144
 145 #define DEFINE_COMMUTATIVITY_CHECK_WRT(op_tag, op_sign) \
 146 template<class Type, class TypeB> \
 147     void check_commutativity_wrt_##op_tag(const Type& a, const TypeB& b) \
 148 { \
 149     Type left  = a op_sign b; \
 150     Type right = b op_sign a; \
 151     BOOST_CHECK(left==right); \
 152 }
 153
 154 #define CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag) check_commutativity_wrt_equal_##op_tag
 155 #define CHECK_COMMUTATIVITY_WRT(op_tag) check_commutativity_wrt_##op_tag
 156
 157 DEFINE_COMMUTATIVITY_CHECK_WRT      (plus,  + )
 158 DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(plus,  + )
 159 DEFINE_COMMUTATIVITY_CHECK_WRT      (pipe,  | )
 160 DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(pipe,  | )
 161 DEFINE_COMMUTATIVITY_CHECK_WRT      (et,    & )
 162 DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(et,    & )
 163 DEFINE_COMMUTATIVITY_CHECK_WRT      (caret, ^ )
 164 DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ )
 165
 166 //------------------------------------------------------------------------------
 167 // Natural inversion
 168 //------------------------------------------------------------------------------
 169
 170 #define DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
 171 template<class Type> \
 172     void check_partial_inversion_wrt_equal_##plus_tag \
 173 (typename equality<Type>::type* equal, const Type& identity_element, const Type& var_a) \
 174 { \
 175     Type positive_difference  = var_a - var_a; \
 176     BOOST_CHECK((*equal)(positive_difference, identity_element)); \
 177 }
 178
 179 #define DEFINE_PARTIAL_INVERSION_CHECK_WRT(plus_tag, plus_sign) \
 180 template<class Type> \
 181     void check_partial_inversion_wrt_##plus_tag \
 182 (const Type& identity_element, const Type& var_a) \
 183 { \
 184     Type positive_difference  = var_a - var_a; \
 185     BOOST_CHECK(positive_difference==identity_element); \
 186 }
 187
 188 #define CHECK_PARTIAL_INVERSION_WRT_EQUAL(plus_tag) check_partial_inversion_wrt_equal_##plus_tag
 189 #define CHECK_PARTIAL_INVERSION_WRT(plus_tag) check_partial_inversion_wrt_##plus_tag
 190
 191 DEFINE_PARTIAL_INVERSION_CHECK_WRT      (plus,  + )
 192 DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus,  + )
 193 DEFINE_PARTIAL_INVERSION_CHECK_WRT      (pipe,  | )
 194 DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(pipe,  | )
 195
 196 //------------------------------------------------------------------------------
 197 // Inverse
 198 //------------------------------------------------------------------------------
 199
 200 #define DEFINE_INVERSE_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
 201 template<class Type> \
 202     void check_inverse_wrt_equal_##plus_tag \
 203 (typename equality<Type>::type* equal, const Type& identity_element, const Type& var_a) \
 204 { \
 205     Type positive_difference  = var_a - var_a; \
 206     BOOST_CHECK((*equal)(positive_difference, identity_element)); \
 207     Type negative_difference = (identity_element - var_a) plus_sign var_a; \
 208     BOOST_CHECK((*equal)(negative_difference, identity_element)); \
 209 }
 210
 211 #define DEFINE_INVERSE_CHECK_WRT(plus_tag, plus_sign) \
 212 template<class Type> \
 213     void check_inverse_wrt_##plus_tag \
 214 (const Type& identity_element, const Type& var_a) \
 215 { \
 216     Type positive_difference  = var_a - var_a; \
 217     BOOST_CHECK(positive_difference==identity_element); \
 218     Type negative_difference = (identity_element - var_a) plus_sign var_a; \
 219     BOOST_CHECK(negative_difference==identity_element); \
 220 }
 221
 222 #define CHECK_INVERSE_WRT_EQUAL(plus_tag) check_inverse_wrt_equal_##plus_tag
 223 #define CHECK_INVERSE_WRT(plus_tag) check_inverse_wrt_##plus_tag
 224
 225 DEFINE_INVERSE_CHECK_WRT      (plus,  + )
 226 DEFINE_INVERSE_CHECK_WRT_EQUAL(plus,  + )
 227 DEFINE_INVERSE_CHECK_WRT      (pipe,  | )
 228 DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe,  | )
 229
 230 //------------------------------------------------------------------------------
 231 // Containedness laws (Valid for sets, NOT for maps)
 232 //------------------------------------------------------------------------------
 233 template<class Type, class TypeB>
 234 void check_intersection_containedness(const Type& a, const TypeB& b)
 235 {
 236     BOOST_CHECK_EQUAL(contains(a, a & b), true);
 237     BOOST_CHECK_EQUAL(contains(a, b & a), true);
 238     BOOST_CHECK_EQUAL(within(a & b, a), true);
 239     BOOST_CHECK_EQUAL(within(b & a, a), true);
 240 }
 241
 242 template<class Type, class TypeB>
 243 void check_union_containedness(const Type& a, const TypeB& b)
 244 {
 245     BOOST_CHECK_EQUAL(within(a, a + b), true);
 246     BOOST_CHECK_EQUAL(within(a, b + a), true);
 247     BOOST_CHECK_EQUAL(contains(a + b, a), true);
 248     BOOST_CHECK_EQUAL(contains(b + a, a), true);
 249 }
 250
 251 template<class MapT>
 252 void check_domain_containedness(const MapT& a)
 253 {
 254     typedef typename MapT::set_type set_type;
 255     set_type dom;
 256     domain(dom, a);
 257     BOOST_CHECK_EQUAL(within(dom, a), true);
 258     BOOST_CHECK_EQUAL(contains(a, dom), true);
 259
 260     if(!dom.empty())
 261     {
 262         typename MapT::domain_type a1 = *dom.begin();
 263         BOOST_CHECK_EQUAL(within(a1, a), true);
 264         BOOST_CHECK_EQUAL(contains(a, a1), true);
 265     }
 266 }
 267
 268 //------------------------------------------------------------------------------
 269 // Laws on inner complement, between and distance
 270 //------------------------------------------------------------------------------
 271 template<class Type, class SetT>
 272 bool check_length_as_distance( const Type& object
 273                              , SetT& in_between
 274                              , typename Type::difference_type& between_len
 275                              , typename Type::difference_type& obj_dist )
 276 {
 277     //LAW LengthAsDistance: distance(x) == length(between(x))
 278     icl::between(in_between, object);
 279     between_len  = icl::length(in_between);
 280     obj_dist     = icl::distance(object);
 281     BOOST_CHECK_EQUAL(obj_dist, between_len);
 282     return obj_dist == between_len;
 283 }
 284
 285 template<class Type, class SetT>
 286 bool has_length_as_distance(const Type& object)
 287 {
 288     typedef typename Type::difference_type DiffT;
 289     SetT in_between; DiffT between_len, obj_dist;
 290     return check_length_as_distance(object, in_between, between_len, obj_dist);
 291 }
 292
 293 template<class Type>
 294 bool check_length_complementarity( const Type& object
 295                                  , typename Type::difference_type& obj_len
 296                                  , typename Type::difference_type& obj_dist
 297                                  , typename Type::difference_type& hull_len )
 298 {
 299     //LAW Length Complementarity: length(x) + distance(x) == length(hull(x))
 300     obj_len  = icl::length(object);
 301     obj_dist = icl::distance(object);
 302     hull_len = icl::length(hull(object));
 303     BOOST_CHECK_EQUAL(obj_len + obj_dist, hull_len);
 304     return obj_len + obj_dist == hull_len;
 305 }
 306
 307 template<class Type>
 308 bool has_length_complementarity(const Type& object)
 309 {
 310     typedef typename Type::difference_type DiffT;
 311     DiffT obj_len, obj_dist, hull_len;
 312     return check_length_complementarity(object, obj_len, obj_dist, hull_len);
 313 }
 314
 315 template<class Type, class SetT>
 316 bool check_inner_complementarity(const Type& object, SetT& in_between, SetT& lhs, SetT& rhs)
 317 {
 318     //LAW Inner Complementarity1: domain(x) + between(x)       =e= hull(x)
 319     //LAW Inner Complementarity2: join(domain(x) + between(x))  == hull(x)
 320     SetT dom;
 321     icl::domain(dom, object);
 322     lhs = dom + between(in_between, object);
 323     join(lhs);
 324     rhs = SetT(hull(object));
 325     BOOST_CHECK_EQUAL(lhs, rhs);
 326     return lhs == rhs;
 327 }
 328
 329
 330 template<class Type, class SetT>
 331 bool has_inner_complementarity(const Type& object)
 332 {
 333     SetT in_between, lhs, rhs;
 334     return check_inner_complementarity(object, in_between, lhs, rhs);
 335 }
 336
 337
 338
 339 //==============================================================================
 340 // Law tests are now combined to test algebraic concepts.
 341 //------------------------------------------------------------------------------
 342 // Monodid EAN
 343 //------------------------------------------------------------------------------
 344
 345 #define DEFINE_MONOID_CHECK_WRT_EQUAL(op_tag) \
 346 template<class Type, class TypeB, class TypeC> \
 347 void check_monoid_wrt_equal_##op_tag \
 348 (typename equality<Type>::type* equal, const Type& identity_element, \
 349 const Type& a, const TypeB& b, const TypeC& c) \
 350 { \
 351     CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
 352     CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,identity_element); \
 353 }
 354
 355 #define DEFINE_MONOID_CHECK_WRT(op_tag) \
 356 template<class Type, class TypeB, class TypeC> \
 357 void check_monoid_wrt_##op_tag \
 358 (const Type& identity_element, \
 359 const Type& a, const TypeB& b, const TypeC& c) \
 360 { \
 361     CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
 362     CHECK_NEUTRALITY_WRT(op_tag)(a,identity_element); \
 363 }
 364
 365 DEFINE_MONOID_CHECK_WRT      (plus)
 366 DEFINE_MONOID_CHECK_WRT_EQUAL(plus)
 367 DEFINE_MONOID_CHECK_WRT      (pipe)
 368 DEFINE_MONOID_CHECK_WRT_EQUAL(pipe)
 369 DEFINE_MONOID_CHECK_WRT      (et)
 370 DEFINE_MONOID_CHECK_WRT_EQUAL(et)
 371 DEFINE_MONOID_CHECK_WRT      (caret)
 372 DEFINE_MONOID_CHECK_WRT_EQUAL(caret)
 373
 374 #define CHECK_MONOID_WRT(op_tag) check_monoid_wrt_##op_tag
 375 #define CHECK_MONOID_WRT_EQUAL(op_tag) check_monoid_wrt_equal_##op_tag
 376
 377 //------------------------------------------------------------------------------
 378 // Commutative or Abelian monodid EANC
 379 //------------------------------------------------------------------------------
 380 #define DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(op_tag) \
 381 template<class Type, class TypeB, class TypeC> \
 382 void check_abelian_monoid_wrt_equal_##op_tag \
 383 (typename equality<Type>::type* equal, const Type& identity_element, \
 384 const Type& a, const TypeB& b, const TypeC& c) \
 385 { \
 386     CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
 387     CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,identity_element); \
 388     CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,b); \
 389     CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,c); \
 390 }
 391
 392 #define DEFINE_ABELIAN_MONOID_CHECK_WRT(op_tag) \
 393 template<class Type, class TypeB, class TypeC> \
 394 void check_abelian_monoid_wrt_##op_tag \
 395 (const Type& identity_element, \
 396 const Type& a, const TypeB& b, const TypeC& c) \
 397 { \
 398     CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
 399     CHECK_NEUTRALITY_WRT(op_tag)(a,identity_element); \
 400     CHECK_COMMUTATIVITY_WRT(op_tag)(a,b); \
 401     CHECK_COMMUTATIVITY_WRT(op_tag)(a,c); \
 402 }
 403
 404 DEFINE_ABELIAN_MONOID_CHECK_WRT      (plus)
 405 DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(plus)
 406 DEFINE_ABELIAN_MONOID_CHECK_WRT      (pipe)
 407 DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(pipe)
 408 DEFINE_ABELIAN_MONOID_CHECK_WRT      (et)
 409 DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(et)
 410 DEFINE_ABELIAN_MONOID_CHECK_WRT      (caret)
 411 DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(caret)
 412
 413 #define CHECK_ABELIAN_MONOID_WRT(op_tag) check_abelian_monoid_wrt_##op_tag
 414 #define CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag) check_abelian_monoid_wrt_equal_##op_tag
 415
 416 //------------------------------------------------------------------------------
 417 // Abelian monodid EANC with partial inversion
 418 //------------------------------------------------------------------------------
 419 #define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(op_tag) \
 420 template<class Type, class TypeB, class TypeC> \
 421 void check_partial_invertive_monoid_wrt_equal_##op_tag \
 422 (typename equality<Type>::type* equal, const Type& identity_element, \
 423 const Type& a, const TypeB& b, const TypeC& c) \
 424 { \
 425     CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,identity_element,a,b,c); \
 426     CHECK_PARTIAL_INVERSION_WRT_EQUAL(op_tag)(equal,identity_element,a); \
 427 }
 428
 429 #define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(op_tag) \
 430 template<class Type, class TypeB, class TypeC> \
 431 void check_partial_invertive_monoid_wrt_##op_tag \
 432 (const Type& identity_element, \
 433 const Type& a, const TypeB& b, const TypeC& c) \
 434 { \
 435     CHECK_ABELIAN_MONOID_WRT(op_tag)(identity_element,a,b,c); \
 436     CHECK_PARTIAL_INVERSION_WRT(op_tag)(identity_element,a); \
 437 }
 438
 439 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (plus)
 440 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(plus)
 441 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (pipe)
 442 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(pipe)
 443 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (et)
 444 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(et)
 445 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (caret)
 446 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(caret)
 447
 448 #define CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag) check_partial_invertive_monoid_wrt_##op_tag
 449 #define CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag) check_partial_invertive_monoid_wrt_equal_##op_tag
 450
 451 //------------------------------------------------------------------------------
 452 // Abelian group EANIC
 453 //------------------------------------------------------------------------------
 454
 455 #define DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(op_tag) \
 456 template<class Type, class TypeB, class TypeC> \
 457     void check_abelian_group_wrt_equal_##op_tag \
 458 (typename equality<Type>::type* equal, const Type& identity_element, \
 459 const Type& a, const TypeB& b, const TypeC& c) \
 460 { \
 461     CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,identity_element,a,b,c); \
 462     CHECK_INVERSE_WRT_EQUAL(op_tag)(equal,identity_element,a); \
 463 }
 464
 465 #define DEFINE_ABELIAN_GROUP_CHECK_WRT(op_tag) \
 466 template<class Type, class TypeB, class TypeC> \
 467     void check_abelian_group_wrt_##op_tag \
 468 (const Type& identity_element, \
 469 const Type& a, const TypeB& b, const TypeC& c) \
 470 { \
 471     CHECK_ABELIAN_MONOID_WRT(op_tag)(identity_element,a,b,c); \
 472     CHECK_INVERSE_WRT(op_tag)(identity_element,a); \
 473 }
 474
 475
 476 DEFINE_ABELIAN_GROUP_CHECK_WRT      (plus)
 477 DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(plus)
 478 DEFINE_ABELIAN_GROUP_CHECK_WRT      (pipe)
 479 DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(pipe)
 480
 481 #define CHECK_ABELIAN_GROUP_WRT(op_tag) check_abelian_group_wrt_##op_tag
 482 #define CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag) check_abelian_group_wrt_equal_##op_tag
 483
 484 //------------------------------------------------------------------------------
 485 // Modoid permuted
 486 //------------------------------------------------------------------------------
 487
 488 #define DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(op_tag) \
 489 template<class TypeA, class TypeB, class Assoc> \
 490 void check_monoid_permuted_wrt_equal_##op_tag \
 491 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 492 { \
 493     CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 494     CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 495     CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 496     CHECK_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 497 }
 498
 499 #define DEFINE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
 500 template<class TypeA, class TypeB, class Assoc> \
 501 void check_monoid_permuted_wrt_##op_tag \
 502 (const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 503 { \
 504     CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 505     CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 506     CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 507     CHECK_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 508 }
 509
 510
 511 DEFINE_MONOID_CHECK_PERMUTED_WRT      (plus)
 512 DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
 513 DEFINE_MONOID_CHECK_PERMUTED_WRT      (pipe)
 514 DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
 515 DEFINE_MONOID_CHECK_PERMUTED_WRT      (et)
 516 DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
 517 DEFINE_MONOID_CHECK_PERMUTED_WRT      (caret)
 518 DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)
 519
 520 #define CHECK_MONOID_PERMUTED_WRT(op_tag)       check_monoid_permuted_wrt_##op_tag
 521 #define CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_monoid_permuted_wrt_equal_##op_tag
 522
 523
 524 //------------------------------------------------------------------------------
 525 // Abelian modoid permuted
 526 //------------------------------------------------------------------------------
 527
 528 #define DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(op_tag) \
 529 template<class TypeA, class TypeB, class Assoc> \
 530 void check_abelian_monoid_permuted_wrt_equal_##op_tag \
 531 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 532 { \
 533     CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 534     CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 535     CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 536     CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 537 }
 538
 539 #define DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(op_tag) \
 540 template<class TypeA, class TypeB, class Assoc> \
 541 void check_abelian_monoid_permuted_wrt_##op_tag \
 542 (const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 543 { \
 544     CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 545     CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 546     CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 547     CHECK_ABELIAN_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 548 }
 549
 550
 551 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (plus)
 552 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
 553 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (pipe)
 554 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
 555 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (et)
 556 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
 557 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (caret)
 558 DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)
 559
 560 #define CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)       check_abelian_monoid_permuted_wrt_##op_tag
 561 #define CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_abelian_monoid_permuted_wrt_equal_##op_tag
 562
 563
 564 //------------------------------------------------------------------------------
 565 // Abelian modoid with partial inversion permuted
 566 //------------------------------------------------------------------------------
 567
 568 #define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(op_tag) \
 569 template<class TypeA, class TypeB, class Assoc> \
 570 void check_partial_invertive_monoid_permuted_wrt_equal_##op_tag \
 571 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 572 { \
 573     CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 574     CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 575     CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 576     CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 577 }
 578
 579 #define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
 580 template<class TypeA, class TypeB, class Assoc> \
 581 void check_partial_invertive_monoid_permuted_wrt_##op_tag \
 582 (const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 583 { \
 584     CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 585     CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 586     CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 587     CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 588 }
 589
 590
 591 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (plus)
 592 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
 593 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (pipe)
 594 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
 595 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (et)
 596 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
 597 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (caret)
 598 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)
 599
 600 #define CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)       check_partial_invertive_monoid_permuted_wrt_##op_tag
 601 #define CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_partial_invertive_monoid_permuted_wrt_equal_##op_tag
 602
 603
 604 //------------------------------------------------------------------------------
 605 // Abelian group permuted
 606 //------------------------------------------------------------------------------
 607
 608 #define DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(op_tag) \
 609 template<class TypeA, class TypeB, class Assoc> \
 610     void check_abelian_group_permuted_wrt_equal_##op_tag \
 611 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 612 { \
 613     CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 614     CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 615     CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 616     CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 617 }
 618
 619 #define DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(op_tag) \
 620 template<class TypeA, class TypeB, class Assoc> \
 621     void check_abelian_group_permuted_wrt_##op_tag \
 622 (const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
 623 { \
 624     CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
 625     CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
 626     CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
 627     CHECK_ABELIAN_GROUP_WRT(op_tag)(icl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
 628 }
 629
 630
 631 DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT      (plus)
 632 DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(plus)
 633 DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT      (pipe)
 634 DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(pipe)
 635
 636 #define CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)       check_abelian_group_permuted_wrt_##op_tag
 637 #define CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag) check_abelian_group_permuted_wrt_equal_##op_tag
 638
 639
 640 //------------------------------------------------------------------------------
 641 // Modoid instance
 642 //------------------------------------------------------------------------------
 643
 644 #define DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(op_tag) \
 645 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 646 void check_monoid_instance_wrt_equal_##op_tag \
 647 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 648  const AssocA& ass_a, const AssocB& ass_b) \
 649 { \
 650     CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
 651     CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
 652     CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
 653 }
 654
 655 #define DEFINE_MONOID_CHECK_INSTANCE_WRT(op_tag) \
 656 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 657 void check_monoid_instance_wrt_##op_tag \
 658 (const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 659  const AssocA& ass_a, const AssocB& ass_b) \
 660 { \
 661     CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
 662     CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
 663     CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 664 }
 665
 666 DEFINE_MONOID_CHECK_INSTANCE_WRT      (plus)
 667 DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
 668 DEFINE_MONOID_CHECK_INSTANCE_WRT      (pipe)
 669 DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
 670 DEFINE_MONOID_CHECK_INSTANCE_WRT      (et)
 671 DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
 672 DEFINE_MONOID_CHECK_INSTANCE_WRT      (caret)
 673 DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)
 674
 675 #define CHECK_MONOID_INSTANCE_WRT(op_tag)       check_monoid_instance_wrt_##op_tag
 676 #define CHECK_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_monoid_instance_wrt_equal_##op_tag
 677
 678
 679
 680 //------------------------------------------------------------------------------
 681 // Abelian modoid instance
 682 //------------------------------------------------------------------------------
 683
 684 #define DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(op_tag) \
 685 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 686 void check_abelian_monoid_instance_wrt_equal_##op_tag \
 687 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 688  const AssocA& ass_a, const AssocB& ass_b) \
 689 { \
 690     CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
 691     CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
 692     CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
 693 }
 694
 695 #define DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(op_tag) \
 696 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 697 void check_abelian_monoid_instance_wrt_##op_tag \
 698 (const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 699  const AssocA& ass_a, const AssocB& ass_b) \
 700 { \
 701     CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
 702     CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
 703     CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 704 }
 705
 706 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (plus)
 707 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
 708 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (pipe)
 709 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
 710 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (et)
 711 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
 712 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (caret)
 713 DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)
 714
 715 #define CHECK_ABELIAN_MONOID_INSTANCE_WRT(op_tag)       check_abelian_monoid_instance_wrt_##op_tag
 716 #define CHECK_ABELIAN_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_abelian_monoid_instance_wrt_equal_##op_tag
 717
 718
 719 //------------------------------------------------------------------------------
 720 // Abelian partial invertive modoid instance
 721 //------------------------------------------------------------------------------
 722
 723 #define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(op_tag) \
 724 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 725 void check_partial_invertive_monoid_instance_wrt_equal_##op_tag \
 726 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 727  const AssocA& ass_a, const AssocB& ass_b) \
 728 { \
 729     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
 730     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
 731     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
 732 }
 733
 734 #define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(op_tag) \
 735 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 736 void check_partial_invertive_monoid_instance_wrt_##op_tag \
 737 (const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 738  const AssocA& ass_a, const AssocB& ass_b) \
 739 { \
 740     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
 741     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
 742     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 743 }
 744
 745 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (plus)
 746 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
 747 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (pipe)
 748 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
 749 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (et)
 750 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
 751 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (caret)
 752 DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)
 753
 754 #define CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(op_tag)       check_partial_invertive_monoid_instance_wrt_##op_tag
 755 #define CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_partial_invertive_monoid_instance_wrt_equal_##op_tag
 756
 757
 758 //------------------------------------------------------------------------------
 759 // Abelian group instance
 760 //------------------------------------------------------------------------------
 761
 762 #define DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(op_tag) \
 763 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 764     void check_abelian_group_instance_wrt_equal_##op_tag \
 765 (typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 766  const AssocA& ass_a, const AssocB& ass_b) \
 767 { \
 768     CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, var_c);\
 769     CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_a);\
 770     CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag)(equal, var_a, var_b, ass_b);\
 771 }
 772
 773 #define DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(op_tag) \
 774 template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
 775     void check_abelian_group_instance_wrt_##op_tag \
 776 (const TypeA& var_a, const TypeB& var_b, const TypeC& var_c, \
 777  const AssocA& ass_a, const AssocB& ass_b) \
 778 { \
 779     CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, var_c);\
 780     CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_a);\
 781     CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 782 }
 783
 784 DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT      (plus)
 785 DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(plus)
 786 DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT      (pipe)
 787 DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(pipe)
 788
 789 #define CHECK_ABELIAN_GROUP_INSTANCE_WRT(op_tag)       check_abelian_group_instance_wrt_##op_tag
 790 #define CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(op_tag) check_abelian_group_instance_wrt_equal_##op_tag
 791
 792 }} // namespace icl boost
 793
 794 #endif // BOOST_LIBS_ICL_TEST_ICL_LAWS_HPP_JOFA_090119
 795