1/*-----------------------------------------------------------------------------+
2Copyright (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
14namespace boost{namespace icl
15{
16
17template<class Type>
18struct 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) \
37template<class Type, class TypeB, class TypeC> \
38void 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) \
46template<class Type, class TypeB, class TypeC> \
47void check_associativity_wrt_equal_##op_tag \
48(typename equality<Type>::type* equal, \
49const 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.
63DEFINE_ASSOCIATIVITY_CHECK_WRT (plus, + )
64DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus, + )
65DEFINE_ASSOCIATIVITY_CHECK_WRT (pipe, | )
66DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(pipe, | )
67DEFINE_ASSOCIATIVITY_CHECK_WRT (et, & )
68DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(et, & )
69DEFINE_ASSOCIATIVITY_CHECK_WRT (caret, ^ )
70DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(caret, ^ )
71
72
73//------------------------------------------------------------------------------
74// Neutrality
75//------------------------------------------------------------------------------
76
77#define DEFINE_RIGHT_NEUTRALITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
78template<class Type> \
79void 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) \
88template<class Type> \
89void 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) \
98template<class Type> \
99void 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) \
108template<class Type> \
109void 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
120DEFINE_NEUTRALITY_CHECK_WRT (plus, + )
121DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(plus, + )
122DEFINE_NEUTRALITY_CHECK_WRT (pipe, | )
123DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(pipe, | )
124DEFINE_NEUTRALITY_CHECK_WRT (minus, - )
125DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(minus, - )
126DEFINE_NEUTRALITY_CHECK_WRT (et, & )
127DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(et, & )
128DEFINE_NEUTRALITY_CHECK_WRT (caret, ^ )
129DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(caret, ^ )
130
131//------------------------------------------------------------------------------
132// Commutativity
133//------------------------------------------------------------------------------
134
135#define DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
136template<class Type, class TypeB> \
137void 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) \
146template<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
157DEFINE_COMMUTATIVITY_CHECK_WRT (plus, + )
158DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(plus, + )
159DEFINE_COMMUTATIVITY_CHECK_WRT (pipe, | )
160DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(pipe, | )
161DEFINE_COMMUTATIVITY_CHECK_WRT (et, & )
162DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(et, & )
163DEFINE_COMMUTATIVITY_CHECK_WRT (caret, ^ )
164DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ )
165
166//------------------------------------------------------------------------------
167// Natural inversion
168//------------------------------------------------------------------------------
169
170#define DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
171template<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) \
180template<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
191DEFINE_PARTIAL_INVERSION_CHECK_WRT (plus, + )
192DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus, + )
193DEFINE_PARTIAL_INVERSION_CHECK_WRT (pipe, | )
194DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(pipe, | )
195
196//------------------------------------------------------------------------------
197// Inverse
198//------------------------------------------------------------------------------
199
200#define DEFINE_INVERSE_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
201template<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) \
212template<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
225DEFINE_INVERSE_CHECK_WRT (plus, + )
226DEFINE_INVERSE_CHECK_WRT_EQUAL(plus, + )
227DEFINE_INVERSE_CHECK_WRT (pipe, | )
228DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe, | )
229
230//------------------------------------------------------------------------------
231// Containedness laws (Valid for sets, NOT for maps)
232//------------------------------------------------------------------------------
233template<class Type, class TypeB>
234void 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
242template<class Type, class TypeB>
243void 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
251template<class MapT>
252void 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//------------------------------------------------------------------------------
271template<class Type, class SetT>
272bool 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
285template<class Type, class SetT>
286bool 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
293template<class Type>
294bool 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
307template<class Type>
308bool 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
315template<class Type, class SetT>
316bool 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
330template<class Type, class SetT>
331bool 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) \
346template<class Type, class TypeB, class TypeC> \
347void check_monoid_wrt_equal_##op_tag \
348(typename equality<Type>::type* equal, const Type& identity_element, \
349const 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) \
356template<class Type, class TypeB, class TypeC> \
357void check_monoid_wrt_##op_tag \
358(const Type& identity_element, \
359const 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
365DEFINE_MONOID_CHECK_WRT (plus)
366DEFINE_MONOID_CHECK_WRT_EQUAL(plus)
367DEFINE_MONOID_CHECK_WRT (pipe)
368DEFINE_MONOID_CHECK_WRT_EQUAL(pipe)
369DEFINE_MONOID_CHECK_WRT (et)
370DEFINE_MONOID_CHECK_WRT_EQUAL(et)
371DEFINE_MONOID_CHECK_WRT (caret)
372DEFINE_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) \
381template<class Type, class TypeB, class TypeC> \
382void check_abelian_monoid_wrt_equal_##op_tag \
383(typename equality<Type>::type* equal, const Type& identity_element, \
384const 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) \
393template<class Type, class TypeB, class TypeC> \
394void check_abelian_monoid_wrt_##op_tag \
395(const Type& identity_element, \
396const 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
404DEFINE_ABELIAN_MONOID_CHECK_WRT (plus)
405DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(plus)
406DEFINE_ABELIAN_MONOID_CHECK_WRT (pipe)
407DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(pipe)
408DEFINE_ABELIAN_MONOID_CHECK_WRT (et)
409DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(et)
410DEFINE_ABELIAN_MONOID_CHECK_WRT (caret)
411DEFINE_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) \
420template<class Type, class TypeB, class TypeC> \
421void check_partial_invertive_monoid_wrt_equal_##op_tag \
422(typename equality<Type>::type* equal, const Type& identity_element, \
423const 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) \
430template<class Type, class TypeB, class TypeC> \
431void check_partial_invertive_monoid_wrt_##op_tag \
432(const Type& identity_element, \
433const 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
439DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (plus)
440DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(plus)
441DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (pipe)
442DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(pipe)
443DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (et)
444DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(et)
445DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT (caret)
446DEFINE_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) \
456template<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, \
459const 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) \
466template<class Type, class TypeB, class TypeC> \
467 void check_abelian_group_wrt_##op_tag \
468(const Type& identity_element, \
469const 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
476DEFINE_ABELIAN_GROUP_CHECK_WRT (plus)
477DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(plus)
478DEFINE_ABELIAN_GROUP_CHECK_WRT (pipe)
479DEFINE_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) \
489template<class TypeA, class TypeB, class Assoc> \
490void 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) \
500template<class TypeA, class TypeB, class Assoc> \
501void 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
511DEFINE_MONOID_CHECK_PERMUTED_WRT (plus)
512DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
513DEFINE_MONOID_CHECK_PERMUTED_WRT (pipe)
514DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
515DEFINE_MONOID_CHECK_PERMUTED_WRT (et)
516DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
517DEFINE_MONOID_CHECK_PERMUTED_WRT (caret)
518DEFINE_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) \
529template<class TypeA, class TypeB, class Assoc> \
530void 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) \
540template<class TypeA, class TypeB, class Assoc> \
541void 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
551DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (plus)
552DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
553DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (pipe)
554DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
555DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (et)
556DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
557DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT (caret)
558DEFINE_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) \
569template<class TypeA, class TypeB, class Assoc> \
570void 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) \
580template<class TypeA, class TypeB, class Assoc> \
581void 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
591DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (plus)
592DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
593DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (pipe)
594DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
595DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (et)
596DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
597DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT (caret)
598DEFINE_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) \
609template<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) \
620template<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
631DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT (plus)
632DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(plus)
633DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT (pipe)
634DEFINE_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) \
645template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
646void 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) \
656template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
657void 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
666DEFINE_MONOID_CHECK_INSTANCE_WRT (plus)
667DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
668DEFINE_MONOID_CHECK_INSTANCE_WRT (pipe)
669DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
670DEFINE_MONOID_CHECK_INSTANCE_WRT (et)
671DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
672DEFINE_MONOID_CHECK_INSTANCE_WRT (caret)
673DEFINE_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) \
685template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
686void 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) \
696template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
697void 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
706DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (plus)
707DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
708DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (pipe)
709DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
710DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (et)
711DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
712DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT (caret)
713DEFINE_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) \
724template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
725void 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) \
735template<class TypeA, class TypeB, class TypeC, class AssocA, class AssocB> \
736void 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
745DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (plus)
746DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
747DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (pipe)
748DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
749DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (et)
750DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
751DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT (caret)
752DEFINE_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) \
763template<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) \
774template<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
784DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT (plus)
785DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(plus)
786DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT (pipe)
787DEFINE_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
796

source code of boost/libs/icl/test/test_laws.hpp