From ae8104fa89203da5af6c4d19bbb44808f77247d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Fri, 11 Sep 2015 14:12:00 +0100 Subject: [PATCH 1/9] Added DISCARD macros. --- include/boost/preprocessor/discard.hpp | 62 ++++++++++++++++++++++++++++++++++ include/boost/preprocessor/library.hpp | 1 + 2 files changed, 63 insertions(+) create mode 100644 include/boost/preprocessor/discard.hpp diff --git a/include/boost/preprocessor/discard.hpp b/include/boost/preprocessor/discard.hpp new file mode 100644 index 00000000..4350f5fb --- /dev/null +++ b/include/boost/preprocessor/discard.hpp @@ -0,0 +1,62 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_DISCARD_HPP +# define BOOST_PREPROCESSOR_DISCARD_HPP + + + +# include +# include + + + +# if BOOST_PP_VARIADICS + +# define BOOST_PP_DISCARD(...) +# define BOOST_PP_DISCARD_MIN(...) 0 +# define BOOST_PP_DISCARD_MAX(...) BOOST_PP_LIMIT_MAG + +# endif /* BOOST_PP_VARIADICS */ + + + +# define BOOST_PP_DISCARD_1(a) +# define BOOST_PP_DISCARD_2(a, b) +# define BOOST_PP_DISCARD_3(a, b, c) +# define BOOST_PP_DISCARD_4(a, b, c, d) +# define BOOST_PP_DISCARD_5(a, b, c, d, e) +# define BOOST_PP_DISCARD_6(a, b, c, d, e, f) +# define BOOST_PP_DISCARD_7(a, b, c, d, e, f, g) +# define BOOST_PP_DISCARD_8(a, b, c, d, e, f, g, h) +# define BOOST_PP_DISCARD_9(a, b, c, d, e, f, g, h, i) + +# define BOOST_PP_DISCARD_MIN_1(a) 0 +# define BOOST_PP_DISCARD_MIN_2(a, b) 0 +# define BOOST_PP_DISCARD_MIN_3(a, b, c) 0 +# define BOOST_PP_DISCARD_MIN_4(a, b, c, d) 0 +# define BOOST_PP_DISCARD_MIN_5(a, b, c, d, e) 0 +# define BOOST_PP_DISCARD_MIN_6(a, b, c, d, e, f) 0 +# define BOOST_PP_DISCARD_MIN_7(a, b, c, d, e, f, g) 0 +# define BOOST_PP_DISCARD_MIN_8(a, b, c, d, e, f, g, h) 0 +# define BOOST_PP_DISCARD_MIN_9(a, b, c, d, e, f, g, h, i) 0 + +# define BOOST_PP_DISCARD_MAX_1(a) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_2(a, b) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_3(a, b, c) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_4(a, b, c, d) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_5(a, b, c, d, e) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_6(a, b, c, d, e, f) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_7(a, b, c, d, e, f, g) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_8(a, b, c, d, e, f, g, h) BOOST_PP_LIMIT_MAG +# define BOOST_PP_DISCARD_MAX_9(a, b, c, d, e, f, g, h, i) BOOST_PP_LIMIT_MAG + + + +#endif /* !BOOST_PREPROCESSOR_DISCARD_HPP */ diff --git a/include/boost/preprocessor/library.hpp b/include/boost/preprocessor/library.hpp index 3fb03d88..98b21463 100644 --- a/include/boost/preprocessor/library.hpp +++ b/include/boost/preprocessor/library.hpp @@ -20,6 +20,7 @@ # include # include # include +# include # include # include # include From dd2e61a0c2d9ff420b5a9eb700e4dde6c92ea3a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 17:27:50 +0100 Subject: [PATCH 2/9] Added BOOST_PP_ARRAY_EQUAL and tests. --- include/boost/preprocessor/array.hpp | 1 + include/boost/preprocessor/array/equal.hpp | 305 +++++++++++++++++++++++++++++ test/array.cxx | 7 + 3 files changed, 313 insertions(+) create mode 100644 include/boost/preprocessor/array/equal.hpp diff --git a/include/boost/preprocessor/array.hpp b/include/boost/preprocessor/array.hpp index 3b6a7719..5bb6634c 100644 --- a/include/boost/preprocessor/array.hpp +++ b/include/boost/preprocessor/array.hpp @@ -16,6 +16,7 @@ # include # include # include +# include # include # include # include diff --git a/include/boost/preprocessor/array/equal.hpp b/include/boost/preprocessor/array/equal.hpp new file mode 100644 index 00000000..ddfec932 --- /dev/null +++ b/include/boost/preprocessor/array/equal.hpp @@ -0,0 +1,305 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_ARRAY_EQUAL_HPP +# define BOOST_PREPROCESSOR_ARRAY_EQUAL_HPP + + + +# include +# include +# include +# include +# include +# include +# include + + + +/* +** BOOST_PP_ARRAY_EQUAL +** Compares two PP_ARRAYs. +** Expands to 1 if they're equal, to 0 otherwise +*/ + +# define BOOST_PP_ARRAY_EQUAL(A1, A2) \ + BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_ARRAY_SIZE(A1), \ + BOOST_PP_ARRAY_SIZE(A2)), \ + BOOST_PP_CAT(BOOST_PP_AE_, BOOST_PP_ARRAY_SIZE(A1)), \ + BOOST_PP_DISCARD_MIN_2) \ + (A1, A2) + + + +/* +** Internal boilerplate +*/ + +# define BOOST_PP_AE_0(A1, A2) 1 + +# define BOOST_PP_AE_1(A1, A2) BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 0, A1), BOOST_PP_ARRAY_ELEM( 0, A2)) +# define BOOST_PP_AE_2(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 1, A1), BOOST_PP_ARRAY_ELEM( 1, A2)), BOOST_PP_AE_1(A1, A2)) +# define BOOST_PP_AE_3(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 2, A1), BOOST_PP_ARRAY_ELEM( 2, A2)), BOOST_PP_AE_2(A1, A2)) +# define BOOST_PP_AE_4(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 3, A1), BOOST_PP_ARRAY_ELEM( 3, A2)), BOOST_PP_AE_3(A1, A2)) +# define BOOST_PP_AE_5(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 4, A1), BOOST_PP_ARRAY_ELEM( 4, A2)), BOOST_PP_AE_4(A1, A2)) +# define BOOST_PP_AE_6(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 5, A1), BOOST_PP_ARRAY_ELEM( 5, A2)), BOOST_PP_AE_5(A1, A2)) +# define BOOST_PP_AE_7(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 6, A1), BOOST_PP_ARRAY_ELEM( 6, A2)), BOOST_PP_AE_6(A1, A2)) +# define BOOST_PP_AE_8(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 7, A1), BOOST_PP_ARRAY_ELEM( 7, A2)), BOOST_PP_AE_7(A1, A2)) +# define BOOST_PP_AE_9(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 8, A1), BOOST_PP_ARRAY_ELEM( 8, A2)), BOOST_PP_AE_8(A1, A2)) +# define BOOST_PP_AE_10(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 9, A1), BOOST_PP_ARRAY_ELEM( 9, A2)), BOOST_PP_AE_9(A1, A2)) +# define BOOST_PP_AE_11(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 10, A1), BOOST_PP_ARRAY_ELEM( 10, A2)), BOOST_PP_AE_10(A1, A2)) +# define BOOST_PP_AE_12(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 11, A1), BOOST_PP_ARRAY_ELEM( 11, A2)), BOOST_PP_AE_11(A1, A2)) +# define BOOST_PP_AE_13(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 12, A1), BOOST_PP_ARRAY_ELEM( 12, A2)), BOOST_PP_AE_12(A1, A2)) +# define BOOST_PP_AE_14(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 13, A1), BOOST_PP_ARRAY_ELEM( 13, A2)), BOOST_PP_AE_13(A1, A2)) +# define BOOST_PP_AE_15(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 14, A1), BOOST_PP_ARRAY_ELEM( 14, A2)), BOOST_PP_AE_14(A1, A2)) +# define BOOST_PP_AE_16(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 15, A1), BOOST_PP_ARRAY_ELEM( 15, A2)), BOOST_PP_AE_15(A1, A2)) +# define BOOST_PP_AE_17(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 16, A1), BOOST_PP_ARRAY_ELEM( 16, A2)), BOOST_PP_AE_16(A1, A2)) +# define BOOST_PP_AE_18(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 17, A1), BOOST_PP_ARRAY_ELEM( 17, A2)), BOOST_PP_AE_17(A1, A2)) +# define BOOST_PP_AE_19(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 18, A1), BOOST_PP_ARRAY_ELEM( 18, A2)), BOOST_PP_AE_18(A1, A2)) +# define BOOST_PP_AE_20(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 19, A1), BOOST_PP_ARRAY_ELEM( 19, A2)), BOOST_PP_AE_19(A1, A2)) +# define BOOST_PP_AE_21(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 20, A1), BOOST_PP_ARRAY_ELEM( 20, A2)), BOOST_PP_AE_20(A1, A2)) +# define BOOST_PP_AE_22(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 21, A1), BOOST_PP_ARRAY_ELEM( 21, A2)), BOOST_PP_AE_21(A1, A2)) +# define BOOST_PP_AE_23(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 22, A1), BOOST_PP_ARRAY_ELEM( 22, A2)), BOOST_PP_AE_22(A1, A2)) +# define BOOST_PP_AE_24(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 23, A1), BOOST_PP_ARRAY_ELEM( 23, A2)), BOOST_PP_AE_23(A1, A2)) +# define BOOST_PP_AE_25(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 24, A1), BOOST_PP_ARRAY_ELEM( 24, A2)), BOOST_PP_AE_24(A1, A2)) +# define BOOST_PP_AE_26(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 25, A1), BOOST_PP_ARRAY_ELEM( 25, A2)), BOOST_PP_AE_25(A1, A2)) +# define BOOST_PP_AE_27(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 26, A1), BOOST_PP_ARRAY_ELEM( 26, A2)), BOOST_PP_AE_26(A1, A2)) +# define BOOST_PP_AE_28(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 27, A1), BOOST_PP_ARRAY_ELEM( 27, A2)), BOOST_PP_AE_27(A1, A2)) +# define BOOST_PP_AE_29(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 28, A1), BOOST_PP_ARRAY_ELEM( 28, A2)), BOOST_PP_AE_28(A1, A2)) +# define BOOST_PP_AE_30(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 29, A1), BOOST_PP_ARRAY_ELEM( 29, A2)), BOOST_PP_AE_29(A1, A2)) +# define BOOST_PP_AE_31(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 30, A1), BOOST_PP_ARRAY_ELEM( 30, A2)), BOOST_PP_AE_30(A1, A2)) +# define BOOST_PP_AE_32(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 31, A1), BOOST_PP_ARRAY_ELEM( 31, A2)), BOOST_PP_AE_31(A1, A2)) +# define BOOST_PP_AE_33(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 32, A1), BOOST_PP_ARRAY_ELEM( 32, A2)), BOOST_PP_AE_32(A1, A2)) +# define BOOST_PP_AE_34(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 33, A1), BOOST_PP_ARRAY_ELEM( 33, A2)), BOOST_PP_AE_33(A1, A2)) +# define BOOST_PP_AE_35(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 34, A1), BOOST_PP_ARRAY_ELEM( 34, A2)), BOOST_PP_AE_34(A1, A2)) +# define BOOST_PP_AE_36(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 35, A1), BOOST_PP_ARRAY_ELEM( 35, A2)), BOOST_PP_AE_35(A1, A2)) +# define BOOST_PP_AE_37(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 36, A1), BOOST_PP_ARRAY_ELEM( 36, A2)), BOOST_PP_AE_36(A1, A2)) +# define BOOST_PP_AE_38(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 37, A1), BOOST_PP_ARRAY_ELEM( 37, A2)), BOOST_PP_AE_37(A1, A2)) +# define BOOST_PP_AE_39(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 38, A1), BOOST_PP_ARRAY_ELEM( 38, A2)), BOOST_PP_AE_38(A1, A2)) +# define BOOST_PP_AE_40(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 39, A1), BOOST_PP_ARRAY_ELEM( 39, A2)), BOOST_PP_AE_39(A1, A2)) +# define BOOST_PP_AE_41(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 40, A1), BOOST_PP_ARRAY_ELEM( 40, A2)), BOOST_PP_AE_40(A1, A2)) +# define BOOST_PP_AE_42(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 41, A1), BOOST_PP_ARRAY_ELEM( 41, A2)), BOOST_PP_AE_41(A1, A2)) +# define BOOST_PP_AE_43(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 42, A1), BOOST_PP_ARRAY_ELEM( 42, A2)), BOOST_PP_AE_42(A1, A2)) +# define BOOST_PP_AE_44(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 43, A1), BOOST_PP_ARRAY_ELEM( 43, A2)), BOOST_PP_AE_43(A1, A2)) +# define BOOST_PP_AE_45(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 44, A1), BOOST_PP_ARRAY_ELEM( 44, A2)), BOOST_PP_AE_44(A1, A2)) +# define BOOST_PP_AE_46(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 45, A1), BOOST_PP_ARRAY_ELEM( 45, A2)), BOOST_PP_AE_45(A1, A2)) +# define BOOST_PP_AE_47(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 46, A1), BOOST_PP_ARRAY_ELEM( 46, A2)), BOOST_PP_AE_46(A1, A2)) +# define BOOST_PP_AE_48(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 47, A1), BOOST_PP_ARRAY_ELEM( 47, A2)), BOOST_PP_AE_47(A1, A2)) +# define BOOST_PP_AE_49(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 48, A1), BOOST_PP_ARRAY_ELEM( 48, A2)), BOOST_PP_AE_48(A1, A2)) +# define BOOST_PP_AE_50(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 49, A1), BOOST_PP_ARRAY_ELEM( 49, A2)), BOOST_PP_AE_49(A1, A2)) +# define BOOST_PP_AE_51(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 50, A1), BOOST_PP_ARRAY_ELEM( 50, A2)), BOOST_PP_AE_50(A1, A2)) +# define BOOST_PP_AE_52(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 51, A1), BOOST_PP_ARRAY_ELEM( 51, A2)), BOOST_PP_AE_51(A1, A2)) +# define BOOST_PP_AE_53(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 52, A1), BOOST_PP_ARRAY_ELEM( 52, A2)), BOOST_PP_AE_52(A1, A2)) +# define BOOST_PP_AE_54(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 53, A1), BOOST_PP_ARRAY_ELEM( 53, A2)), BOOST_PP_AE_53(A1, A2)) +# define BOOST_PP_AE_55(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 54, A1), BOOST_PP_ARRAY_ELEM( 54, A2)), BOOST_PP_AE_54(A1, A2)) +# define BOOST_PP_AE_56(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 55, A1), BOOST_PP_ARRAY_ELEM( 55, A2)), BOOST_PP_AE_55(A1, A2)) +# define BOOST_PP_AE_57(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 56, A1), BOOST_PP_ARRAY_ELEM( 56, A2)), BOOST_PP_AE_56(A1, A2)) +# define BOOST_PP_AE_58(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 57, A1), BOOST_PP_ARRAY_ELEM( 57, A2)), BOOST_PP_AE_57(A1, A2)) +# define BOOST_PP_AE_59(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 58, A1), BOOST_PP_ARRAY_ELEM( 58, A2)), BOOST_PP_AE_58(A1, A2)) +# define BOOST_PP_AE_60(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 59, A1), BOOST_PP_ARRAY_ELEM( 59, A2)), BOOST_PP_AE_59(A1, A2)) +# define BOOST_PP_AE_61(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 60, A1), BOOST_PP_ARRAY_ELEM( 60, A2)), BOOST_PP_AE_60(A1, A2)) +# define BOOST_PP_AE_62(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 61, A1), BOOST_PP_ARRAY_ELEM( 61, A2)), BOOST_PP_AE_61(A1, A2)) +# define BOOST_PP_AE_63(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 62, A1), BOOST_PP_ARRAY_ELEM( 62, A2)), BOOST_PP_AE_62(A1, A2)) +# define BOOST_PP_AE_64(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 63, A1), BOOST_PP_ARRAY_ELEM( 63, A2)), BOOST_PP_AE_63(A1, A2)) +# define BOOST_PP_AE_65(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 64, A1), BOOST_PP_ARRAY_ELEM( 64, A2)), BOOST_PP_AE_64(A1, A2)) +# define BOOST_PP_AE_66(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 65, A1), BOOST_PP_ARRAY_ELEM( 65, A2)), BOOST_PP_AE_65(A1, A2)) +# define BOOST_PP_AE_67(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 66, A1), BOOST_PP_ARRAY_ELEM( 66, A2)), BOOST_PP_AE_66(A1, A2)) +# define BOOST_PP_AE_68(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 67, A1), BOOST_PP_ARRAY_ELEM( 67, A2)), BOOST_PP_AE_67(A1, A2)) +# define BOOST_PP_AE_69(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 68, A1), BOOST_PP_ARRAY_ELEM( 68, A2)), BOOST_PP_AE_68(A1, A2)) +# define BOOST_PP_AE_70(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 69, A1), BOOST_PP_ARRAY_ELEM( 69, A2)), BOOST_PP_AE_69(A1, A2)) +# define BOOST_PP_AE_71(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 70, A1), BOOST_PP_ARRAY_ELEM( 70, A2)), BOOST_PP_AE_70(A1, A2)) +# define BOOST_PP_AE_72(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 71, A1), BOOST_PP_ARRAY_ELEM( 71, A2)), BOOST_PP_AE_71(A1, A2)) +# define BOOST_PP_AE_73(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 72, A1), BOOST_PP_ARRAY_ELEM( 72, A2)), BOOST_PP_AE_72(A1, A2)) +# define BOOST_PP_AE_74(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 73, A1), BOOST_PP_ARRAY_ELEM( 73, A2)), BOOST_PP_AE_73(A1, A2)) +# define BOOST_PP_AE_75(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 74, A1), BOOST_PP_ARRAY_ELEM( 74, A2)), BOOST_PP_AE_74(A1, A2)) +# define BOOST_PP_AE_76(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 75, A1), BOOST_PP_ARRAY_ELEM( 75, A2)), BOOST_PP_AE_75(A1, A2)) +# define BOOST_PP_AE_77(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 76, A1), BOOST_PP_ARRAY_ELEM( 76, A2)), BOOST_PP_AE_76(A1, A2)) +# define BOOST_PP_AE_78(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 77, A1), BOOST_PP_ARRAY_ELEM( 77, A2)), BOOST_PP_AE_77(A1, A2)) +# define BOOST_PP_AE_79(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 78, A1), BOOST_PP_ARRAY_ELEM( 78, A2)), BOOST_PP_AE_78(A1, A2)) +# define BOOST_PP_AE_80(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 79, A1), BOOST_PP_ARRAY_ELEM( 79, A2)), BOOST_PP_AE_79(A1, A2)) +# define BOOST_PP_AE_81(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 80, A1), BOOST_PP_ARRAY_ELEM( 80, A2)), BOOST_PP_AE_80(A1, A2)) +# define BOOST_PP_AE_82(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 81, A1), BOOST_PP_ARRAY_ELEM( 81, A2)), BOOST_PP_AE_81(A1, A2)) +# define BOOST_PP_AE_83(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 82, A1), BOOST_PP_ARRAY_ELEM( 82, A2)), BOOST_PP_AE_82(A1, A2)) +# define BOOST_PP_AE_84(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 83, A1), BOOST_PP_ARRAY_ELEM( 83, A2)), BOOST_PP_AE_83(A1, A2)) +# define BOOST_PP_AE_85(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 84, A1), BOOST_PP_ARRAY_ELEM( 84, A2)), BOOST_PP_AE_84(A1, A2)) +# define BOOST_PP_AE_86(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 85, A1), BOOST_PP_ARRAY_ELEM( 85, A2)), BOOST_PP_AE_85(A1, A2)) +# define BOOST_PP_AE_87(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 86, A1), BOOST_PP_ARRAY_ELEM( 86, A2)), BOOST_PP_AE_86(A1, A2)) +# define BOOST_PP_AE_88(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 87, A1), BOOST_PP_ARRAY_ELEM( 87, A2)), BOOST_PP_AE_87(A1, A2)) +# define BOOST_PP_AE_89(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 88, A1), BOOST_PP_ARRAY_ELEM( 88, A2)), BOOST_PP_AE_88(A1, A2)) +# define BOOST_PP_AE_90(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 89, A1), BOOST_PP_ARRAY_ELEM( 89, A2)), BOOST_PP_AE_89(A1, A2)) +# define BOOST_PP_AE_91(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 90, A1), BOOST_PP_ARRAY_ELEM( 90, A2)), BOOST_PP_AE_90(A1, A2)) +# define BOOST_PP_AE_92(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 91, A1), BOOST_PP_ARRAY_ELEM( 91, A2)), BOOST_PP_AE_91(A1, A2)) +# define BOOST_PP_AE_93(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 92, A1), BOOST_PP_ARRAY_ELEM( 92, A2)), BOOST_PP_AE_92(A1, A2)) +# define BOOST_PP_AE_94(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 93, A1), BOOST_PP_ARRAY_ELEM( 93, A2)), BOOST_PP_AE_93(A1, A2)) +# define BOOST_PP_AE_95(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 94, A1), BOOST_PP_ARRAY_ELEM( 94, A2)), BOOST_PP_AE_94(A1, A2)) +# define BOOST_PP_AE_96(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 95, A1), BOOST_PP_ARRAY_ELEM( 95, A2)), BOOST_PP_AE_95(A1, A2)) +# define BOOST_PP_AE_97(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 96, A1), BOOST_PP_ARRAY_ELEM( 96, A2)), BOOST_PP_AE_96(A1, A2)) +# define BOOST_PP_AE_98(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 97, A1), BOOST_PP_ARRAY_ELEM( 97, A2)), BOOST_PP_AE_97(A1, A2)) +# define BOOST_PP_AE_99(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 98, A1), BOOST_PP_ARRAY_ELEM( 98, A2)), BOOST_PP_AE_98(A1, A2)) +# define BOOST_PP_AE_100(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM( 99, A1), BOOST_PP_ARRAY_ELEM( 99, A2)), BOOST_PP_AE_99(A1, A2)) +# define BOOST_PP_AE_101(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(100, A1), BOOST_PP_ARRAY_ELEM(100, A2)), BOOST_PP_AE_100(A1, A2)) +# define BOOST_PP_AE_102(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(101, A1), BOOST_PP_ARRAY_ELEM(101, A2)), BOOST_PP_AE_101(A1, A2)) +# define BOOST_PP_AE_103(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(102, A1), BOOST_PP_ARRAY_ELEM(102, A2)), BOOST_PP_AE_102(A1, A2)) +# define BOOST_PP_AE_104(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(103, A1), BOOST_PP_ARRAY_ELEM(103, A2)), BOOST_PP_AE_103(A1, A2)) +# define BOOST_PP_AE_105(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(104, A1), BOOST_PP_ARRAY_ELEM(104, A2)), BOOST_PP_AE_104(A1, A2)) +# define BOOST_PP_AE_106(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(105, A1), BOOST_PP_ARRAY_ELEM(105, A2)), BOOST_PP_AE_105(A1, A2)) +# define BOOST_PP_AE_107(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(106, A1), BOOST_PP_ARRAY_ELEM(106, A2)), BOOST_PP_AE_106(A1, A2)) +# define BOOST_PP_AE_108(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(107, A1), BOOST_PP_ARRAY_ELEM(107, A2)), BOOST_PP_AE_107(A1, A2)) +# define BOOST_PP_AE_109(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(108, A1), BOOST_PP_ARRAY_ELEM(108, A2)), BOOST_PP_AE_108(A1, A2)) +# define BOOST_PP_AE_110(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(109, A1), BOOST_PP_ARRAY_ELEM(109, A2)), BOOST_PP_AE_109(A1, A2)) +# define BOOST_PP_AE_111(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(110, A1), BOOST_PP_ARRAY_ELEM(110, A2)), BOOST_PP_AE_110(A1, A2)) +# define BOOST_PP_AE_112(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(111, A1), BOOST_PP_ARRAY_ELEM(111, A2)), BOOST_PP_AE_111(A1, A2)) +# define BOOST_PP_AE_113(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(112, A1), BOOST_PP_ARRAY_ELEM(112, A2)), BOOST_PP_AE_112(A1, A2)) +# define BOOST_PP_AE_114(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(113, A1), BOOST_PP_ARRAY_ELEM(113, A2)), BOOST_PP_AE_113(A1, A2)) +# define BOOST_PP_AE_115(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(114, A1), BOOST_PP_ARRAY_ELEM(114, A2)), BOOST_PP_AE_114(A1, A2)) +# define BOOST_PP_AE_116(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(115, A1), BOOST_PP_ARRAY_ELEM(115, A2)), BOOST_PP_AE_115(A1, A2)) +# define BOOST_PP_AE_117(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(116, A1), BOOST_PP_ARRAY_ELEM(116, A2)), BOOST_PP_AE_116(A1, A2)) +# define BOOST_PP_AE_118(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(117, A1), BOOST_PP_ARRAY_ELEM(117, A2)), BOOST_PP_AE_117(A1, A2)) +# define BOOST_PP_AE_119(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(118, A1), BOOST_PP_ARRAY_ELEM(118, A2)), BOOST_PP_AE_118(A1, A2)) +# define BOOST_PP_AE_120(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(119, A1), BOOST_PP_ARRAY_ELEM(119, A2)), BOOST_PP_AE_119(A1, A2)) +# define BOOST_PP_AE_121(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(120, A1), BOOST_PP_ARRAY_ELEM(120, A2)), BOOST_PP_AE_120(A1, A2)) +# define BOOST_PP_AE_122(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(121, A1), BOOST_PP_ARRAY_ELEM(121, A2)), BOOST_PP_AE_121(A1, A2)) +# define BOOST_PP_AE_123(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(122, A1), BOOST_PP_ARRAY_ELEM(122, A2)), BOOST_PP_AE_122(A1, A2)) +# define BOOST_PP_AE_124(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(123, A1), BOOST_PP_ARRAY_ELEM(123, A2)), BOOST_PP_AE_123(A1, A2)) +# define BOOST_PP_AE_125(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(124, A1), BOOST_PP_ARRAY_ELEM(124, A2)), BOOST_PP_AE_124(A1, A2)) +# define BOOST_PP_AE_126(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(125, A1), BOOST_PP_ARRAY_ELEM(125, A2)), BOOST_PP_AE_125(A1, A2)) +# define BOOST_PP_AE_127(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(126, A1), BOOST_PP_ARRAY_ELEM(126, A2)), BOOST_PP_AE_126(A1, A2)) +# define BOOST_PP_AE_128(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(127, A1), BOOST_PP_ARRAY_ELEM(127, A2)), BOOST_PP_AE_127(A1, A2)) +# define BOOST_PP_AE_129(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(128, A1), BOOST_PP_ARRAY_ELEM(128, A2)), BOOST_PP_AE_128(A1, A2)) +# define BOOST_PP_AE_130(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(129, A1), BOOST_PP_ARRAY_ELEM(129, A2)), BOOST_PP_AE_129(A1, A2)) +# define BOOST_PP_AE_131(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(130, A1), BOOST_PP_ARRAY_ELEM(130, A2)), BOOST_PP_AE_130(A1, A2)) +# define BOOST_PP_AE_132(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(131, A1), BOOST_PP_ARRAY_ELEM(131, A2)), BOOST_PP_AE_131(A1, A2)) +# define BOOST_PP_AE_133(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(132, A1), BOOST_PP_ARRAY_ELEM(132, A2)), BOOST_PP_AE_132(A1, A2)) +# define BOOST_PP_AE_134(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(133, A1), BOOST_PP_ARRAY_ELEM(133, A2)), BOOST_PP_AE_133(A1, A2)) +# define BOOST_PP_AE_135(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(134, A1), BOOST_PP_ARRAY_ELEM(134, A2)), BOOST_PP_AE_134(A1, A2)) +# define BOOST_PP_AE_136(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(135, A1), BOOST_PP_ARRAY_ELEM(135, A2)), BOOST_PP_AE_135(A1, A2)) +# define BOOST_PP_AE_137(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(136, A1), BOOST_PP_ARRAY_ELEM(136, A2)), BOOST_PP_AE_136(A1, A2)) +# define BOOST_PP_AE_138(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(137, A1), BOOST_PP_ARRAY_ELEM(137, A2)), BOOST_PP_AE_137(A1, A2)) +# define BOOST_PP_AE_139(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(138, A1), BOOST_PP_ARRAY_ELEM(138, A2)), BOOST_PP_AE_138(A1, A2)) +# define BOOST_PP_AE_140(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(139, A1), BOOST_PP_ARRAY_ELEM(139, A2)), BOOST_PP_AE_139(A1, A2)) +# define BOOST_PP_AE_141(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(140, A1), BOOST_PP_ARRAY_ELEM(140, A2)), BOOST_PP_AE_140(A1, A2)) +# define BOOST_PP_AE_142(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(141, A1), BOOST_PP_ARRAY_ELEM(141, A2)), BOOST_PP_AE_141(A1, A2)) +# define BOOST_PP_AE_143(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(142, A1), BOOST_PP_ARRAY_ELEM(142, A2)), BOOST_PP_AE_142(A1, A2)) +# define BOOST_PP_AE_144(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(143, A1), BOOST_PP_ARRAY_ELEM(143, A2)), BOOST_PP_AE_143(A1, A2)) +# define BOOST_PP_AE_145(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(144, A1), BOOST_PP_ARRAY_ELEM(144, A2)), BOOST_PP_AE_144(A1, A2)) +# define BOOST_PP_AE_146(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(145, A1), BOOST_PP_ARRAY_ELEM(145, A2)), BOOST_PP_AE_145(A1, A2)) +# define BOOST_PP_AE_147(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(146, A1), BOOST_PP_ARRAY_ELEM(146, A2)), BOOST_PP_AE_146(A1, A2)) +# define BOOST_PP_AE_148(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(147, A1), BOOST_PP_ARRAY_ELEM(147, A2)), BOOST_PP_AE_147(A1, A2)) +# define BOOST_PP_AE_149(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(148, A1), BOOST_PP_ARRAY_ELEM(148, A2)), BOOST_PP_AE_148(A1, A2)) +# define BOOST_PP_AE_150(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(149, A1), BOOST_PP_ARRAY_ELEM(149, A2)), BOOST_PP_AE_149(A1, A2)) +# define BOOST_PP_AE_151(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(150, A1), BOOST_PP_ARRAY_ELEM(150, A2)), BOOST_PP_AE_150(A1, A2)) +# define BOOST_PP_AE_152(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(151, A1), BOOST_PP_ARRAY_ELEM(151, A2)), BOOST_PP_AE_151(A1, A2)) +# define BOOST_PP_AE_153(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(152, A1), BOOST_PP_ARRAY_ELEM(152, A2)), BOOST_PP_AE_152(A1, A2)) +# define BOOST_PP_AE_154(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(153, A1), BOOST_PP_ARRAY_ELEM(153, A2)), BOOST_PP_AE_153(A1, A2)) +# define BOOST_PP_AE_155(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(154, A1), BOOST_PP_ARRAY_ELEM(154, A2)), BOOST_PP_AE_154(A1, A2)) +# define BOOST_PP_AE_156(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(155, A1), BOOST_PP_ARRAY_ELEM(155, A2)), BOOST_PP_AE_155(A1, A2)) +# define BOOST_PP_AE_157(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(156, A1), BOOST_PP_ARRAY_ELEM(156, A2)), BOOST_PP_AE_156(A1, A2)) +# define BOOST_PP_AE_158(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(157, A1), BOOST_PP_ARRAY_ELEM(157, A2)), BOOST_PP_AE_157(A1, A2)) +# define BOOST_PP_AE_159(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(158, A1), BOOST_PP_ARRAY_ELEM(158, A2)), BOOST_PP_AE_158(A1, A2)) +# define BOOST_PP_AE_160(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(159, A1), BOOST_PP_ARRAY_ELEM(159, A2)), BOOST_PP_AE_159(A1, A2)) +# define BOOST_PP_AE_161(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(160, A1), BOOST_PP_ARRAY_ELEM(160, A2)), BOOST_PP_AE_160(A1, A2)) +# define BOOST_PP_AE_162(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(161, A1), BOOST_PP_ARRAY_ELEM(161, A2)), BOOST_PP_AE_161(A1, A2)) +# define BOOST_PP_AE_163(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(162, A1), BOOST_PP_ARRAY_ELEM(162, A2)), BOOST_PP_AE_162(A1, A2)) +# define BOOST_PP_AE_164(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(163, A1), BOOST_PP_ARRAY_ELEM(163, A2)), BOOST_PP_AE_163(A1, A2)) +# define BOOST_PP_AE_165(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(164, A1), BOOST_PP_ARRAY_ELEM(164, A2)), BOOST_PP_AE_164(A1, A2)) +# define BOOST_PP_AE_166(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(165, A1), BOOST_PP_ARRAY_ELEM(165, A2)), BOOST_PP_AE_165(A1, A2)) +# define BOOST_PP_AE_167(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(166, A1), BOOST_PP_ARRAY_ELEM(166, A2)), BOOST_PP_AE_166(A1, A2)) +# define BOOST_PP_AE_168(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(167, A1), BOOST_PP_ARRAY_ELEM(167, A2)), BOOST_PP_AE_167(A1, A2)) +# define BOOST_PP_AE_169(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(168, A1), BOOST_PP_ARRAY_ELEM(168, A2)), BOOST_PP_AE_168(A1, A2)) +# define BOOST_PP_AE_170(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(169, A1), BOOST_PP_ARRAY_ELEM(169, A2)), BOOST_PP_AE_169(A1, A2)) +# define BOOST_PP_AE_171(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(170, A1), BOOST_PP_ARRAY_ELEM(170, A2)), BOOST_PP_AE_170(A1, A2)) +# define BOOST_PP_AE_172(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(171, A1), BOOST_PP_ARRAY_ELEM(171, A2)), BOOST_PP_AE_171(A1, A2)) +# define BOOST_PP_AE_173(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(172, A1), BOOST_PP_ARRAY_ELEM(172, A2)), BOOST_PP_AE_172(A1, A2)) +# define BOOST_PP_AE_174(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(173, A1), BOOST_PP_ARRAY_ELEM(173, A2)), BOOST_PP_AE_173(A1, A2)) +# define BOOST_PP_AE_175(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(174, A1), BOOST_PP_ARRAY_ELEM(174, A2)), BOOST_PP_AE_174(A1, A2)) +# define BOOST_PP_AE_176(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(175, A1), BOOST_PP_ARRAY_ELEM(175, A2)), BOOST_PP_AE_175(A1, A2)) +# define BOOST_PP_AE_177(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(176, A1), BOOST_PP_ARRAY_ELEM(176, A2)), BOOST_PP_AE_176(A1, A2)) +# define BOOST_PP_AE_178(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(177, A1), BOOST_PP_ARRAY_ELEM(177, A2)), BOOST_PP_AE_177(A1, A2)) +# define BOOST_PP_AE_179(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(178, A1), BOOST_PP_ARRAY_ELEM(178, A2)), BOOST_PP_AE_178(A1, A2)) +# define BOOST_PP_AE_180(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(179, A1), BOOST_PP_ARRAY_ELEM(179, A2)), BOOST_PP_AE_179(A1, A2)) +# define BOOST_PP_AE_181(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(180, A1), BOOST_PP_ARRAY_ELEM(180, A2)), BOOST_PP_AE_180(A1, A2)) +# define BOOST_PP_AE_182(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(181, A1), BOOST_PP_ARRAY_ELEM(181, A2)), BOOST_PP_AE_181(A1, A2)) +# define BOOST_PP_AE_183(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(182, A1), BOOST_PP_ARRAY_ELEM(182, A2)), BOOST_PP_AE_182(A1, A2)) +# define BOOST_PP_AE_184(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(183, A1), BOOST_PP_ARRAY_ELEM(183, A2)), BOOST_PP_AE_183(A1, A2)) +# define BOOST_PP_AE_185(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(184, A1), BOOST_PP_ARRAY_ELEM(184, A2)), BOOST_PP_AE_184(A1, A2)) +# define BOOST_PP_AE_186(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(185, A1), BOOST_PP_ARRAY_ELEM(185, A2)), BOOST_PP_AE_185(A1, A2)) +# define BOOST_PP_AE_187(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(186, A1), BOOST_PP_ARRAY_ELEM(186, A2)), BOOST_PP_AE_186(A1, A2)) +# define BOOST_PP_AE_188(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(187, A1), BOOST_PP_ARRAY_ELEM(187, A2)), BOOST_PP_AE_187(A1, A2)) +# define BOOST_PP_AE_189(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(188, A1), BOOST_PP_ARRAY_ELEM(188, A2)), BOOST_PP_AE_188(A1, A2)) +# define BOOST_PP_AE_190(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(189, A1), BOOST_PP_ARRAY_ELEM(189, A2)), BOOST_PP_AE_189(A1, A2)) +# define BOOST_PP_AE_191(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(190, A1), BOOST_PP_ARRAY_ELEM(190, A2)), BOOST_PP_AE_190(A1, A2)) +# define BOOST_PP_AE_192(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(191, A1), BOOST_PP_ARRAY_ELEM(191, A2)), BOOST_PP_AE_191(A1, A2)) +# define BOOST_PP_AE_193(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(192, A1), BOOST_PP_ARRAY_ELEM(192, A2)), BOOST_PP_AE_192(A1, A2)) +# define BOOST_PP_AE_194(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(193, A1), BOOST_PP_ARRAY_ELEM(193, A2)), BOOST_PP_AE_193(A1, A2)) +# define BOOST_PP_AE_195(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(194, A1), BOOST_PP_ARRAY_ELEM(194, A2)), BOOST_PP_AE_194(A1, A2)) +# define BOOST_PP_AE_196(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(195, A1), BOOST_PP_ARRAY_ELEM(195, A2)), BOOST_PP_AE_195(A1, A2)) +# define BOOST_PP_AE_197(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(196, A1), BOOST_PP_ARRAY_ELEM(196, A2)), BOOST_PP_AE_196(A1, A2)) +# define BOOST_PP_AE_198(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(197, A1), BOOST_PP_ARRAY_ELEM(197, A2)), BOOST_PP_AE_197(A1, A2)) +# define BOOST_PP_AE_199(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(198, A1), BOOST_PP_ARRAY_ELEM(198, A2)), BOOST_PP_AE_198(A1, A2)) +# define BOOST_PP_AE_200(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(199, A1), BOOST_PP_ARRAY_ELEM(199, A2)), BOOST_PP_AE_199(A1, A2)) +# define BOOST_PP_AE_201(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(200, A1), BOOST_PP_ARRAY_ELEM(200, A2)), BOOST_PP_AE_200(A1, A2)) +# define BOOST_PP_AE_202(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(201, A1), BOOST_PP_ARRAY_ELEM(201, A2)), BOOST_PP_AE_201(A1, A2)) +# define BOOST_PP_AE_203(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(202, A1), BOOST_PP_ARRAY_ELEM(202, A2)), BOOST_PP_AE_202(A1, A2)) +# define BOOST_PP_AE_204(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(203, A1), BOOST_PP_ARRAY_ELEM(203, A2)), BOOST_PP_AE_203(A1, A2)) +# define BOOST_PP_AE_205(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(204, A1), BOOST_PP_ARRAY_ELEM(204, A2)), BOOST_PP_AE_204(A1, A2)) +# define BOOST_PP_AE_206(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(205, A1), BOOST_PP_ARRAY_ELEM(205, A2)), BOOST_PP_AE_205(A1, A2)) +# define BOOST_PP_AE_207(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(206, A1), BOOST_PP_ARRAY_ELEM(206, A2)), BOOST_PP_AE_206(A1, A2)) +# define BOOST_PP_AE_208(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(207, A1), BOOST_PP_ARRAY_ELEM(207, A2)), BOOST_PP_AE_207(A1, A2)) +# define BOOST_PP_AE_209(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(208, A1), BOOST_PP_ARRAY_ELEM(208, A2)), BOOST_PP_AE_208(A1, A2)) +# define BOOST_PP_AE_210(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(209, A1), BOOST_PP_ARRAY_ELEM(209, A2)), BOOST_PP_AE_209(A1, A2)) +# define BOOST_PP_AE_211(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(210, A1), BOOST_PP_ARRAY_ELEM(210, A2)), BOOST_PP_AE_210(A1, A2)) +# define BOOST_PP_AE_212(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(211, A1), BOOST_PP_ARRAY_ELEM(211, A2)), BOOST_PP_AE_211(A1, A2)) +# define BOOST_PP_AE_213(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(212, A1), BOOST_PP_ARRAY_ELEM(212, A2)), BOOST_PP_AE_212(A1, A2)) +# define BOOST_PP_AE_214(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(213, A1), BOOST_PP_ARRAY_ELEM(213, A2)), BOOST_PP_AE_213(A1, A2)) +# define BOOST_PP_AE_215(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(214, A1), BOOST_PP_ARRAY_ELEM(214, A2)), BOOST_PP_AE_214(A1, A2)) +# define BOOST_PP_AE_216(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(215, A1), BOOST_PP_ARRAY_ELEM(215, A2)), BOOST_PP_AE_215(A1, A2)) +# define BOOST_PP_AE_217(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(216, A1), BOOST_PP_ARRAY_ELEM(216, A2)), BOOST_PP_AE_216(A1, A2)) +# define BOOST_PP_AE_218(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(217, A1), BOOST_PP_ARRAY_ELEM(217, A2)), BOOST_PP_AE_217(A1, A2)) +# define BOOST_PP_AE_219(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(218, A1), BOOST_PP_ARRAY_ELEM(218, A2)), BOOST_PP_AE_218(A1, A2)) +# define BOOST_PP_AE_220(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(219, A1), BOOST_PP_ARRAY_ELEM(219, A2)), BOOST_PP_AE_219(A1, A2)) +# define BOOST_PP_AE_221(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(220, A1), BOOST_PP_ARRAY_ELEM(220, A2)), BOOST_PP_AE_220(A1, A2)) +# define BOOST_PP_AE_222(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(221, A1), BOOST_PP_ARRAY_ELEM(221, A2)), BOOST_PP_AE_221(A1, A2)) +# define BOOST_PP_AE_223(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(222, A1), BOOST_PP_ARRAY_ELEM(222, A2)), BOOST_PP_AE_222(A1, A2)) +# define BOOST_PP_AE_224(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(223, A1), BOOST_PP_ARRAY_ELEM(223, A2)), BOOST_PP_AE_223(A1, A2)) +# define BOOST_PP_AE_225(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(224, A1), BOOST_PP_ARRAY_ELEM(224, A2)), BOOST_PP_AE_224(A1, A2)) +# define BOOST_PP_AE_226(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(225, A1), BOOST_PP_ARRAY_ELEM(225, A2)), BOOST_PP_AE_225(A1, A2)) +# define BOOST_PP_AE_227(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(226, A1), BOOST_PP_ARRAY_ELEM(226, A2)), BOOST_PP_AE_226(A1, A2)) +# define BOOST_PP_AE_228(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(227, A1), BOOST_PP_ARRAY_ELEM(227, A2)), BOOST_PP_AE_227(A1, A2)) +# define BOOST_PP_AE_229(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(228, A1), BOOST_PP_ARRAY_ELEM(228, A2)), BOOST_PP_AE_228(A1, A2)) +# define BOOST_PP_AE_230(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(229, A1), BOOST_PP_ARRAY_ELEM(229, A2)), BOOST_PP_AE_229(A1, A2)) +# define BOOST_PP_AE_231(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(230, A1), BOOST_PP_ARRAY_ELEM(230, A2)), BOOST_PP_AE_230(A1, A2)) +# define BOOST_PP_AE_232(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(231, A1), BOOST_PP_ARRAY_ELEM(231, A2)), BOOST_PP_AE_231(A1, A2)) +# define BOOST_PP_AE_233(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(232, A1), BOOST_PP_ARRAY_ELEM(232, A2)), BOOST_PP_AE_232(A1, A2)) +# define BOOST_PP_AE_234(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(233, A1), BOOST_PP_ARRAY_ELEM(233, A2)), BOOST_PP_AE_233(A1, A2)) +# define BOOST_PP_AE_235(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(234, A1), BOOST_PP_ARRAY_ELEM(234, A2)), BOOST_PP_AE_234(A1, A2)) +# define BOOST_PP_AE_236(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(235, A1), BOOST_PP_ARRAY_ELEM(235, A2)), BOOST_PP_AE_235(A1, A2)) +# define BOOST_PP_AE_237(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(236, A1), BOOST_PP_ARRAY_ELEM(236, A2)), BOOST_PP_AE_236(A1, A2)) +# define BOOST_PP_AE_238(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(237, A1), BOOST_PP_ARRAY_ELEM(237, A2)), BOOST_PP_AE_237(A1, A2)) +# define BOOST_PP_AE_239(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(238, A1), BOOST_PP_ARRAY_ELEM(238, A2)), BOOST_PP_AE_238(A1, A2)) +# define BOOST_PP_AE_240(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(239, A1), BOOST_PP_ARRAY_ELEM(239, A2)), BOOST_PP_AE_239(A1, A2)) +# define BOOST_PP_AE_241(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(240, A1), BOOST_PP_ARRAY_ELEM(240, A2)), BOOST_PP_AE_240(A1, A2)) +# define BOOST_PP_AE_242(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(241, A1), BOOST_PP_ARRAY_ELEM(241, A2)), BOOST_PP_AE_241(A1, A2)) +# define BOOST_PP_AE_243(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(242, A1), BOOST_PP_ARRAY_ELEM(242, A2)), BOOST_PP_AE_242(A1, A2)) +# define BOOST_PP_AE_244(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(243, A1), BOOST_PP_ARRAY_ELEM(243, A2)), BOOST_PP_AE_243(A1, A2)) +# define BOOST_PP_AE_245(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(244, A1), BOOST_PP_ARRAY_ELEM(244, A2)), BOOST_PP_AE_244(A1, A2)) +# define BOOST_PP_AE_246(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(245, A1), BOOST_PP_ARRAY_ELEM(245, A2)), BOOST_PP_AE_245(A1, A2)) +# define BOOST_PP_AE_247(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(246, A1), BOOST_PP_ARRAY_ELEM(246, A2)), BOOST_PP_AE_246(A1, A2)) +# define BOOST_PP_AE_248(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(247, A1), BOOST_PP_ARRAY_ELEM(247, A2)), BOOST_PP_AE_247(A1, A2)) +# define BOOST_PP_AE_249(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(248, A1), BOOST_PP_ARRAY_ELEM(248, A2)), BOOST_PP_AE_248(A1, A2)) +# define BOOST_PP_AE_250(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(249, A1), BOOST_PP_ARRAY_ELEM(249, A2)), BOOST_PP_AE_249(A1, A2)) +# define BOOST_PP_AE_251(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(250, A1), BOOST_PP_ARRAY_ELEM(250, A2)), BOOST_PP_AE_250(A1, A2)) +# define BOOST_PP_AE_252(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(251, A1), BOOST_PP_ARRAY_ELEM(251, A2)), BOOST_PP_AE_251(A1, A2)) +# define BOOST_PP_AE_253(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(252, A1), BOOST_PP_ARRAY_ELEM(252, A2)), BOOST_PP_AE_252(A1, A2)) +# define BOOST_PP_AE_254(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(253, A1), BOOST_PP_ARRAY_ELEM(253, A2)), BOOST_PP_AE_253(A1, A2)) +# define BOOST_PP_AE_255(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(254, A1), BOOST_PP_ARRAY_ELEM(254, A2)), BOOST_PP_AE_254(A1, A2)) +# define BOOST_PP_AE_256(A1, A2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_ARRAY_ELEM(255, A1), BOOST_PP_ARRAY_ELEM(255, A2)), BOOST_PP_AE_255(A1, A2)) + + + +#endif /* !BOOST_PREPROCESSOR_ARRAY_EQUAL_HPP */ diff --git a/test/array.cxx b/test/array.cxx index e6925ab1..be5f7fc6 100644 --- a/test/array.cxx +++ b/test/array.cxx @@ -190,3 +190,10 @@ BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE)) == 3 END BEGIN BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 25 END BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_EMPTY)) == 0 END BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_ONE)) == 1 END + +// equal + +BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_EMPTY, ARRAY_EMPTY) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_EMPTY, ARRAY_LARGE) == 0 END +BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_LARGE, ARRAY_EMPTY) == 0 END +BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_LARGE, ARRAY_LARGE) == 1 END From 3d0c6065e924c0e90156614b1cc4b6e618c2c044 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 17:29:00 +0100 Subject: [PATCH 3/9] Added BOOST_PP_TUPLE_EQUAL and tests. --- include/boost/preprocessor/tuple.hpp | 1 + include/boost/preprocessor/tuple/equal.hpp | 310 +++++++++++++++++++++++++++++ test/tuple.cxx | 7 + 3 files changed, 318 insertions(+) create mode 100644 include/boost/preprocessor/tuple/equal.hpp diff --git a/include/boost/preprocessor/tuple.hpp b/include/boost/preprocessor/tuple.hpp index 76fad365..adbf30e5 100644 --- a/include/boost/preprocessor/tuple.hpp +++ b/include/boost/preprocessor/tuple.hpp @@ -18,6 +18,7 @@ # include # include # include +# include # include # include # include diff --git a/include/boost/preprocessor/tuple/equal.hpp b/include/boost/preprocessor/tuple/equal.hpp new file mode 100644 index 00000000..80944908 --- /dev/null +++ b/include/boost/preprocessor/tuple/equal.hpp @@ -0,0 +1,310 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_TUPLE_EQUAL_HPP +# define BOOST_PREPROCESSOR_TUPLE_EQUAL_HPP + +# include +# if BOOST_PP_VARIADICS + + + +# include +# include +# include +# include +# include +# include +# include + + + +/* +** BOOST_PP_TUPLE_EQUAL +** Compares two PP_TUPLEs. +** Expands to 1 if they're equal, to 0 otherwise +*/ + +# define BOOST_PP_TUPLE_EQUAL(T1, T2) \ + BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_TUPLE_SIZE(T1), \ + BOOST_PP_TUPLE_SIZE(T2)), \ + BOOST_PP_CAT(BOOST_PP_TE_, BOOST_PP_TUPLE_SIZE(T1)), \ + BOOST_PP_DISCARD_MIN_2) \ + (T1, T2) + + + +/* +** Internal boilerplate +*/ + +# define BOOST_PP_TE_0(T1, T2) 1 + +# define BOOST_PP_TE_1(T1, T2) BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 0, T1), BOOST_PP_TUPLE_ELEM( 0, T2)) +# define BOOST_PP_TE_2(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 1, T1), BOOST_PP_TUPLE_ELEM( 1, T2)), BOOST_PP_TE_1(T1, T2)) +# define BOOST_PP_TE_3(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 2, T1), BOOST_PP_TUPLE_ELEM( 2, T2)), BOOST_PP_TE_2(T1, T2)) +# define BOOST_PP_TE_4(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 3, T1), BOOST_PP_TUPLE_ELEM( 3, T2)), BOOST_PP_TE_3(T1, T2)) +# define BOOST_PP_TE_5(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 4, T1), BOOST_PP_TUPLE_ELEM( 4, T2)), BOOST_PP_TE_4(T1, T2)) +# define BOOST_PP_TE_6(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 5, T1), BOOST_PP_TUPLE_ELEM( 5, T2)), BOOST_PP_TE_5(T1, T2)) +# define BOOST_PP_TE_7(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 6, T1), BOOST_PP_TUPLE_ELEM( 6, T2)), BOOST_PP_TE_6(T1, T2)) +# define BOOST_PP_TE_8(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 7, T1), BOOST_PP_TUPLE_ELEM( 7, T2)), BOOST_PP_TE_7(T1, T2)) +# define BOOST_PP_TE_9(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 8, T1), BOOST_PP_TUPLE_ELEM( 8, T2)), BOOST_PP_TE_8(T1, T2)) +# define BOOST_PP_TE_10(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 9, T1), BOOST_PP_TUPLE_ELEM( 9, T2)), BOOST_PP_TE_9(T1, T2)) +# define BOOST_PP_TE_11(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 10, T1), BOOST_PP_TUPLE_ELEM( 10, T2)), BOOST_PP_TE_10(T1, T2)) +# define BOOST_PP_TE_12(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 11, T1), BOOST_PP_TUPLE_ELEM( 11, T2)), BOOST_PP_TE_11(T1, T2)) +# define BOOST_PP_TE_13(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 12, T1), BOOST_PP_TUPLE_ELEM( 12, T2)), BOOST_PP_TE_12(T1, T2)) +# define BOOST_PP_TE_14(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 13, T1), BOOST_PP_TUPLE_ELEM( 13, T2)), BOOST_PP_TE_13(T1, T2)) +# define BOOST_PP_TE_15(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 14, T1), BOOST_PP_TUPLE_ELEM( 14, T2)), BOOST_PP_TE_14(T1, T2)) +# define BOOST_PP_TE_16(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 15, T1), BOOST_PP_TUPLE_ELEM( 15, T2)), BOOST_PP_TE_15(T1, T2)) +# define BOOST_PP_TE_17(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 16, T1), BOOST_PP_TUPLE_ELEM( 16, T2)), BOOST_PP_TE_16(T1, T2)) +# define BOOST_PP_TE_18(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 17, T1), BOOST_PP_TUPLE_ELEM( 17, T2)), BOOST_PP_TE_17(T1, T2)) +# define BOOST_PP_TE_19(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 18, T1), BOOST_PP_TUPLE_ELEM( 18, T2)), BOOST_PP_TE_18(T1, T2)) +# define BOOST_PP_TE_20(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 19, T1), BOOST_PP_TUPLE_ELEM( 19, T2)), BOOST_PP_TE_19(T1, T2)) +# define BOOST_PP_TE_21(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 20, T1), BOOST_PP_TUPLE_ELEM( 20, T2)), BOOST_PP_TE_20(T1, T2)) +# define BOOST_PP_TE_22(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 21, T1), BOOST_PP_TUPLE_ELEM( 21, T2)), BOOST_PP_TE_21(T1, T2)) +# define BOOST_PP_TE_23(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 22, T1), BOOST_PP_TUPLE_ELEM( 22, T2)), BOOST_PP_TE_22(T1, T2)) +# define BOOST_PP_TE_24(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 23, T1), BOOST_PP_TUPLE_ELEM( 23, T2)), BOOST_PP_TE_23(T1, T2)) +# define BOOST_PP_TE_25(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 24, T1), BOOST_PP_TUPLE_ELEM( 24, T2)), BOOST_PP_TE_24(T1, T2)) +# define BOOST_PP_TE_26(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 25, T1), BOOST_PP_TUPLE_ELEM( 25, T2)), BOOST_PP_TE_25(T1, T2)) +# define BOOST_PP_TE_27(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 26, T1), BOOST_PP_TUPLE_ELEM( 26, T2)), BOOST_PP_TE_26(T1, T2)) +# define BOOST_PP_TE_28(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 27, T1), BOOST_PP_TUPLE_ELEM( 27, T2)), BOOST_PP_TE_27(T1, T2)) +# define BOOST_PP_TE_29(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 28, T1), BOOST_PP_TUPLE_ELEM( 28, T2)), BOOST_PP_TE_28(T1, T2)) +# define BOOST_PP_TE_30(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 29, T1), BOOST_PP_TUPLE_ELEM( 29, T2)), BOOST_PP_TE_29(T1, T2)) +# define BOOST_PP_TE_31(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 30, T1), BOOST_PP_TUPLE_ELEM( 30, T2)), BOOST_PP_TE_30(T1, T2)) +# define BOOST_PP_TE_32(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 31, T1), BOOST_PP_TUPLE_ELEM( 31, T2)), BOOST_PP_TE_31(T1, T2)) +# define BOOST_PP_TE_33(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 32, T1), BOOST_PP_TUPLE_ELEM( 32, T2)), BOOST_PP_TE_32(T1, T2)) +# define BOOST_PP_TE_34(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 33, T1), BOOST_PP_TUPLE_ELEM( 33, T2)), BOOST_PP_TE_33(T1, T2)) +# define BOOST_PP_TE_35(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 34, T1), BOOST_PP_TUPLE_ELEM( 34, T2)), BOOST_PP_TE_34(T1, T2)) +# define BOOST_PP_TE_36(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 35, T1), BOOST_PP_TUPLE_ELEM( 35, T2)), BOOST_PP_TE_35(T1, T2)) +# define BOOST_PP_TE_37(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 36, T1), BOOST_PP_TUPLE_ELEM( 36, T2)), BOOST_PP_TE_36(T1, T2)) +# define BOOST_PP_TE_38(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 37, T1), BOOST_PP_TUPLE_ELEM( 37, T2)), BOOST_PP_TE_37(T1, T2)) +# define BOOST_PP_TE_39(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 38, T1), BOOST_PP_TUPLE_ELEM( 38, T2)), BOOST_PP_TE_38(T1, T2)) +# define BOOST_PP_TE_40(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 39, T1), BOOST_PP_TUPLE_ELEM( 39, T2)), BOOST_PP_TE_39(T1, T2)) +# define BOOST_PP_TE_41(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 40, T1), BOOST_PP_TUPLE_ELEM( 40, T2)), BOOST_PP_TE_40(T1, T2)) +# define BOOST_PP_TE_42(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 41, T1), BOOST_PP_TUPLE_ELEM( 41, T2)), BOOST_PP_TE_41(T1, T2)) +# define BOOST_PP_TE_43(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 42, T1), BOOST_PP_TUPLE_ELEM( 42, T2)), BOOST_PP_TE_42(T1, T2)) +# define BOOST_PP_TE_44(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 43, T1), BOOST_PP_TUPLE_ELEM( 43, T2)), BOOST_PP_TE_43(T1, T2)) +# define BOOST_PP_TE_45(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 44, T1), BOOST_PP_TUPLE_ELEM( 44, T2)), BOOST_PP_TE_44(T1, T2)) +# define BOOST_PP_TE_46(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 45, T1), BOOST_PP_TUPLE_ELEM( 45, T2)), BOOST_PP_TE_45(T1, T2)) +# define BOOST_PP_TE_47(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 46, T1), BOOST_PP_TUPLE_ELEM( 46, T2)), BOOST_PP_TE_46(T1, T2)) +# define BOOST_PP_TE_48(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 47, T1), BOOST_PP_TUPLE_ELEM( 47, T2)), BOOST_PP_TE_47(T1, T2)) +# define BOOST_PP_TE_49(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 48, T1), BOOST_PP_TUPLE_ELEM( 48, T2)), BOOST_PP_TE_48(T1, T2)) +# define BOOST_PP_TE_50(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 49, T1), BOOST_PP_TUPLE_ELEM( 49, T2)), BOOST_PP_TE_49(T1, T2)) +# define BOOST_PP_TE_51(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 50, T1), BOOST_PP_TUPLE_ELEM( 50, T2)), BOOST_PP_TE_50(T1, T2)) +# define BOOST_PP_TE_52(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 51, T1), BOOST_PP_TUPLE_ELEM( 51, T2)), BOOST_PP_TE_51(T1, T2)) +# define BOOST_PP_TE_53(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 52, T1), BOOST_PP_TUPLE_ELEM( 52, T2)), BOOST_PP_TE_52(T1, T2)) +# define BOOST_PP_TE_54(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 53, T1), BOOST_PP_TUPLE_ELEM( 53, T2)), BOOST_PP_TE_53(T1, T2)) +# define BOOST_PP_TE_55(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 54, T1), BOOST_PP_TUPLE_ELEM( 54, T2)), BOOST_PP_TE_54(T1, T2)) +# define BOOST_PP_TE_56(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 55, T1), BOOST_PP_TUPLE_ELEM( 55, T2)), BOOST_PP_TE_55(T1, T2)) +# define BOOST_PP_TE_57(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 56, T1), BOOST_PP_TUPLE_ELEM( 56, T2)), BOOST_PP_TE_56(T1, T2)) +# define BOOST_PP_TE_58(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 57, T1), BOOST_PP_TUPLE_ELEM( 57, T2)), BOOST_PP_TE_57(T1, T2)) +# define BOOST_PP_TE_59(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 58, T1), BOOST_PP_TUPLE_ELEM( 58, T2)), BOOST_PP_TE_58(T1, T2)) +# define BOOST_PP_TE_60(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 59, T1), BOOST_PP_TUPLE_ELEM( 59, T2)), BOOST_PP_TE_59(T1, T2)) +# define BOOST_PP_TE_61(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 60, T1), BOOST_PP_TUPLE_ELEM( 60, T2)), BOOST_PP_TE_60(T1, T2)) +# define BOOST_PP_TE_62(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 61, T1), BOOST_PP_TUPLE_ELEM( 61, T2)), BOOST_PP_TE_61(T1, T2)) +# define BOOST_PP_TE_63(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 62, T1), BOOST_PP_TUPLE_ELEM( 62, T2)), BOOST_PP_TE_62(T1, T2)) +# define BOOST_PP_TE_64(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 63, T1), BOOST_PP_TUPLE_ELEM( 63, T2)), BOOST_PP_TE_63(T1, T2)) +# define BOOST_PP_TE_65(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 64, T1), BOOST_PP_TUPLE_ELEM( 64, T2)), BOOST_PP_TE_64(T1, T2)) +# define BOOST_PP_TE_66(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 65, T1), BOOST_PP_TUPLE_ELEM( 65, T2)), BOOST_PP_TE_65(T1, T2)) +# define BOOST_PP_TE_67(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 66, T1), BOOST_PP_TUPLE_ELEM( 66, T2)), BOOST_PP_TE_66(T1, T2)) +# define BOOST_PP_TE_68(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 67, T1), BOOST_PP_TUPLE_ELEM( 67, T2)), BOOST_PP_TE_67(T1, T2)) +# define BOOST_PP_TE_69(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 68, T1), BOOST_PP_TUPLE_ELEM( 68, T2)), BOOST_PP_TE_68(T1, T2)) +# define BOOST_PP_TE_70(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 69, T1), BOOST_PP_TUPLE_ELEM( 69, T2)), BOOST_PP_TE_69(T1, T2)) +# define BOOST_PP_TE_71(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 70, T1), BOOST_PP_TUPLE_ELEM( 70, T2)), BOOST_PP_TE_70(T1, T2)) +# define BOOST_PP_TE_72(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 71, T1), BOOST_PP_TUPLE_ELEM( 71, T2)), BOOST_PP_TE_71(T1, T2)) +# define BOOST_PP_TE_73(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 72, T1), BOOST_PP_TUPLE_ELEM( 72, T2)), BOOST_PP_TE_72(T1, T2)) +# define BOOST_PP_TE_74(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 73, T1), BOOST_PP_TUPLE_ELEM( 73, T2)), BOOST_PP_TE_73(T1, T2)) +# define BOOST_PP_TE_75(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 74, T1), BOOST_PP_TUPLE_ELEM( 74, T2)), BOOST_PP_TE_74(T1, T2)) +# define BOOST_PP_TE_76(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 75, T1), BOOST_PP_TUPLE_ELEM( 75, T2)), BOOST_PP_TE_75(T1, T2)) +# define BOOST_PP_TE_77(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 76, T1), BOOST_PP_TUPLE_ELEM( 76, T2)), BOOST_PP_TE_76(T1, T2)) +# define BOOST_PP_TE_78(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 77, T1), BOOST_PP_TUPLE_ELEM( 77, T2)), BOOST_PP_TE_77(T1, T2)) +# define BOOST_PP_TE_79(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 78, T1), BOOST_PP_TUPLE_ELEM( 78, T2)), BOOST_PP_TE_78(T1, T2)) +# define BOOST_PP_TE_80(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 79, T1), BOOST_PP_TUPLE_ELEM( 79, T2)), BOOST_PP_TE_79(T1, T2)) +# define BOOST_PP_TE_81(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 80, T1), BOOST_PP_TUPLE_ELEM( 80, T2)), BOOST_PP_TE_80(T1, T2)) +# define BOOST_PP_TE_82(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 81, T1), BOOST_PP_TUPLE_ELEM( 81, T2)), BOOST_PP_TE_81(T1, T2)) +# define BOOST_PP_TE_83(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 82, T1), BOOST_PP_TUPLE_ELEM( 82, T2)), BOOST_PP_TE_82(T1, T2)) +# define BOOST_PP_TE_84(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 83, T1), BOOST_PP_TUPLE_ELEM( 83, T2)), BOOST_PP_TE_83(T1, T2)) +# define BOOST_PP_TE_85(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 84, T1), BOOST_PP_TUPLE_ELEM( 84, T2)), BOOST_PP_TE_84(T1, T2)) +# define BOOST_PP_TE_86(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 85, T1), BOOST_PP_TUPLE_ELEM( 85, T2)), BOOST_PP_TE_85(T1, T2)) +# define BOOST_PP_TE_87(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 86, T1), BOOST_PP_TUPLE_ELEM( 86, T2)), BOOST_PP_TE_86(T1, T2)) +# define BOOST_PP_TE_88(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 87, T1), BOOST_PP_TUPLE_ELEM( 87, T2)), BOOST_PP_TE_87(T1, T2)) +# define BOOST_PP_TE_89(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 88, T1), BOOST_PP_TUPLE_ELEM( 88, T2)), BOOST_PP_TE_88(T1, T2)) +# define BOOST_PP_TE_90(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 89, T1), BOOST_PP_TUPLE_ELEM( 89, T2)), BOOST_PP_TE_89(T1, T2)) +# define BOOST_PP_TE_91(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 90, T1), BOOST_PP_TUPLE_ELEM( 90, T2)), BOOST_PP_TE_90(T1, T2)) +# define BOOST_PP_TE_92(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 91, T1), BOOST_PP_TUPLE_ELEM( 91, T2)), BOOST_PP_TE_91(T1, T2)) +# define BOOST_PP_TE_93(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 92, T1), BOOST_PP_TUPLE_ELEM( 92, T2)), BOOST_PP_TE_92(T1, T2)) +# define BOOST_PP_TE_94(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 93, T1), BOOST_PP_TUPLE_ELEM( 93, T2)), BOOST_PP_TE_93(T1, T2)) +# define BOOST_PP_TE_95(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 94, T1), BOOST_PP_TUPLE_ELEM( 94, T2)), BOOST_PP_TE_94(T1, T2)) +# define BOOST_PP_TE_96(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 95, T1), BOOST_PP_TUPLE_ELEM( 95, T2)), BOOST_PP_TE_95(T1, T2)) +# define BOOST_PP_TE_97(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 96, T1), BOOST_PP_TUPLE_ELEM( 96, T2)), BOOST_PP_TE_96(T1, T2)) +# define BOOST_PP_TE_98(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 97, T1), BOOST_PP_TUPLE_ELEM( 97, T2)), BOOST_PP_TE_97(T1, T2)) +# define BOOST_PP_TE_99(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 98, T1), BOOST_PP_TUPLE_ELEM( 98, T2)), BOOST_PP_TE_98(T1, T2)) +# define BOOST_PP_TE_100(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM( 99, T1), BOOST_PP_TUPLE_ELEM( 99, T2)), BOOST_PP_TE_99(T1, T2)) +# define BOOST_PP_TE_101(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(100, T1), BOOST_PP_TUPLE_ELEM(100, T2)), BOOST_PP_TE_100(T1, T2)) +# define BOOST_PP_TE_102(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(101, T1), BOOST_PP_TUPLE_ELEM(101, T2)), BOOST_PP_TE_101(T1, T2)) +# define BOOST_PP_TE_103(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(102, T1), BOOST_PP_TUPLE_ELEM(102, T2)), BOOST_PP_TE_102(T1, T2)) +# define BOOST_PP_TE_104(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(103, T1), BOOST_PP_TUPLE_ELEM(103, T2)), BOOST_PP_TE_103(T1, T2)) +# define BOOST_PP_TE_105(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(104, T1), BOOST_PP_TUPLE_ELEM(104, T2)), BOOST_PP_TE_104(T1, T2)) +# define BOOST_PP_TE_106(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(105, T1), BOOST_PP_TUPLE_ELEM(105, T2)), BOOST_PP_TE_105(T1, T2)) +# define BOOST_PP_TE_107(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(106, T1), BOOST_PP_TUPLE_ELEM(106, T2)), BOOST_PP_TE_106(T1, T2)) +# define BOOST_PP_TE_108(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(107, T1), BOOST_PP_TUPLE_ELEM(107, T2)), BOOST_PP_TE_107(T1, T2)) +# define BOOST_PP_TE_109(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(108, T1), BOOST_PP_TUPLE_ELEM(108, T2)), BOOST_PP_TE_108(T1, T2)) +# define BOOST_PP_TE_110(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(109, T1), BOOST_PP_TUPLE_ELEM(109, T2)), BOOST_PP_TE_109(T1, T2)) +# define BOOST_PP_TE_111(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(110, T1), BOOST_PP_TUPLE_ELEM(110, T2)), BOOST_PP_TE_110(T1, T2)) +# define BOOST_PP_TE_112(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(111, T1), BOOST_PP_TUPLE_ELEM(111, T2)), BOOST_PP_TE_111(T1, T2)) +# define BOOST_PP_TE_113(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(112, T1), BOOST_PP_TUPLE_ELEM(112, T2)), BOOST_PP_TE_112(T1, T2)) +# define BOOST_PP_TE_114(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(113, T1), BOOST_PP_TUPLE_ELEM(113, T2)), BOOST_PP_TE_113(T1, T2)) +# define BOOST_PP_TE_115(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(114, T1), BOOST_PP_TUPLE_ELEM(114, T2)), BOOST_PP_TE_114(T1, T2)) +# define BOOST_PP_TE_116(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(115, T1), BOOST_PP_TUPLE_ELEM(115, T2)), BOOST_PP_TE_115(T1, T2)) +# define BOOST_PP_TE_117(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(116, T1), BOOST_PP_TUPLE_ELEM(116, T2)), BOOST_PP_TE_116(T1, T2)) +# define BOOST_PP_TE_118(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(117, T1), BOOST_PP_TUPLE_ELEM(117, T2)), BOOST_PP_TE_117(T1, T2)) +# define BOOST_PP_TE_119(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(118, T1), BOOST_PP_TUPLE_ELEM(118, T2)), BOOST_PP_TE_118(T1, T2)) +# define BOOST_PP_TE_120(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(119, T1), BOOST_PP_TUPLE_ELEM(119, T2)), BOOST_PP_TE_119(T1, T2)) +# define BOOST_PP_TE_121(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(120, T1), BOOST_PP_TUPLE_ELEM(120, T2)), BOOST_PP_TE_120(T1, T2)) +# define BOOST_PP_TE_122(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(121, T1), BOOST_PP_TUPLE_ELEM(121, T2)), BOOST_PP_TE_121(T1, T2)) +# define BOOST_PP_TE_123(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(122, T1), BOOST_PP_TUPLE_ELEM(122, T2)), BOOST_PP_TE_122(T1, T2)) +# define BOOST_PP_TE_124(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(123, T1), BOOST_PP_TUPLE_ELEM(123, T2)), BOOST_PP_TE_123(T1, T2)) +# define BOOST_PP_TE_125(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(124, T1), BOOST_PP_TUPLE_ELEM(124, T2)), BOOST_PP_TE_124(T1, T2)) +# define BOOST_PP_TE_126(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(125, T1), BOOST_PP_TUPLE_ELEM(125, T2)), BOOST_PP_TE_125(T1, T2)) +# define BOOST_PP_TE_127(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(126, T1), BOOST_PP_TUPLE_ELEM(126, T2)), BOOST_PP_TE_126(T1, T2)) +# define BOOST_PP_TE_128(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(127, T1), BOOST_PP_TUPLE_ELEM(127, T2)), BOOST_PP_TE_127(T1, T2)) +# define BOOST_PP_TE_129(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(128, T1), BOOST_PP_TUPLE_ELEM(128, T2)), BOOST_PP_TE_128(T1, T2)) +# define BOOST_PP_TE_130(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(129, T1), BOOST_PP_TUPLE_ELEM(129, T2)), BOOST_PP_TE_129(T1, T2)) +# define BOOST_PP_TE_131(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(130, T1), BOOST_PP_TUPLE_ELEM(130, T2)), BOOST_PP_TE_130(T1, T2)) +# define BOOST_PP_TE_132(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(131, T1), BOOST_PP_TUPLE_ELEM(131, T2)), BOOST_PP_TE_131(T1, T2)) +# define BOOST_PP_TE_133(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(132, T1), BOOST_PP_TUPLE_ELEM(132, T2)), BOOST_PP_TE_132(T1, T2)) +# define BOOST_PP_TE_134(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(133, T1), BOOST_PP_TUPLE_ELEM(133, T2)), BOOST_PP_TE_133(T1, T2)) +# define BOOST_PP_TE_135(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(134, T1), BOOST_PP_TUPLE_ELEM(134, T2)), BOOST_PP_TE_134(T1, T2)) +# define BOOST_PP_TE_136(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(135, T1), BOOST_PP_TUPLE_ELEM(135, T2)), BOOST_PP_TE_135(T1, T2)) +# define BOOST_PP_TE_137(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(136, T1), BOOST_PP_TUPLE_ELEM(136, T2)), BOOST_PP_TE_136(T1, T2)) +# define BOOST_PP_TE_138(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(137, T1), BOOST_PP_TUPLE_ELEM(137, T2)), BOOST_PP_TE_137(T1, T2)) +# define BOOST_PP_TE_139(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(138, T1), BOOST_PP_TUPLE_ELEM(138, T2)), BOOST_PP_TE_138(T1, T2)) +# define BOOST_PP_TE_140(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(139, T1), BOOST_PP_TUPLE_ELEM(139, T2)), BOOST_PP_TE_139(T1, T2)) +# define BOOST_PP_TE_141(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(140, T1), BOOST_PP_TUPLE_ELEM(140, T2)), BOOST_PP_TE_140(T1, T2)) +# define BOOST_PP_TE_142(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(141, T1), BOOST_PP_TUPLE_ELEM(141, T2)), BOOST_PP_TE_141(T1, T2)) +# define BOOST_PP_TE_143(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(142, T1), BOOST_PP_TUPLE_ELEM(142, T2)), BOOST_PP_TE_142(T1, T2)) +# define BOOST_PP_TE_144(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(143, T1), BOOST_PP_TUPLE_ELEM(143, T2)), BOOST_PP_TE_143(T1, T2)) +# define BOOST_PP_TE_145(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(144, T1), BOOST_PP_TUPLE_ELEM(144, T2)), BOOST_PP_TE_144(T1, T2)) +# define BOOST_PP_TE_146(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(145, T1), BOOST_PP_TUPLE_ELEM(145, T2)), BOOST_PP_TE_145(T1, T2)) +# define BOOST_PP_TE_147(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(146, T1), BOOST_PP_TUPLE_ELEM(146, T2)), BOOST_PP_TE_146(T1, T2)) +# define BOOST_PP_TE_148(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(147, T1), BOOST_PP_TUPLE_ELEM(147, T2)), BOOST_PP_TE_147(T1, T2)) +# define BOOST_PP_TE_149(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(148, T1), BOOST_PP_TUPLE_ELEM(148, T2)), BOOST_PP_TE_148(T1, T2)) +# define BOOST_PP_TE_150(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(149, T1), BOOST_PP_TUPLE_ELEM(149, T2)), BOOST_PP_TE_149(T1, T2)) +# define BOOST_PP_TE_151(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(150, T1), BOOST_PP_TUPLE_ELEM(150, T2)), BOOST_PP_TE_150(T1, T2)) +# define BOOST_PP_TE_152(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(151, T1), BOOST_PP_TUPLE_ELEM(151, T2)), BOOST_PP_TE_151(T1, T2)) +# define BOOST_PP_TE_153(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(152, T1), BOOST_PP_TUPLE_ELEM(152, T2)), BOOST_PP_TE_152(T1, T2)) +# define BOOST_PP_TE_154(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(153, T1), BOOST_PP_TUPLE_ELEM(153, T2)), BOOST_PP_TE_153(T1, T2)) +# define BOOST_PP_TE_155(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(154, T1), BOOST_PP_TUPLE_ELEM(154, T2)), BOOST_PP_TE_154(T1, T2)) +# define BOOST_PP_TE_156(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(155, T1), BOOST_PP_TUPLE_ELEM(155, T2)), BOOST_PP_TE_155(T1, T2)) +# define BOOST_PP_TE_157(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(156, T1), BOOST_PP_TUPLE_ELEM(156, T2)), BOOST_PP_TE_156(T1, T2)) +# define BOOST_PP_TE_158(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(157, T1), BOOST_PP_TUPLE_ELEM(157, T2)), BOOST_PP_TE_157(T1, T2)) +# define BOOST_PP_TE_159(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(158, T1), BOOST_PP_TUPLE_ELEM(158, T2)), BOOST_PP_TE_158(T1, T2)) +# define BOOST_PP_TE_160(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(159, T1), BOOST_PP_TUPLE_ELEM(159, T2)), BOOST_PP_TE_159(T1, T2)) +# define BOOST_PP_TE_161(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(160, T1), BOOST_PP_TUPLE_ELEM(160, T2)), BOOST_PP_TE_160(T1, T2)) +# define BOOST_PP_TE_162(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(161, T1), BOOST_PP_TUPLE_ELEM(161, T2)), BOOST_PP_TE_161(T1, T2)) +# define BOOST_PP_TE_163(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(162, T1), BOOST_PP_TUPLE_ELEM(162, T2)), BOOST_PP_TE_162(T1, T2)) +# define BOOST_PP_TE_164(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(163, T1), BOOST_PP_TUPLE_ELEM(163, T2)), BOOST_PP_TE_163(T1, T2)) +# define BOOST_PP_TE_165(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(164, T1), BOOST_PP_TUPLE_ELEM(164, T2)), BOOST_PP_TE_164(T1, T2)) +# define BOOST_PP_TE_166(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(165, T1), BOOST_PP_TUPLE_ELEM(165, T2)), BOOST_PP_TE_165(T1, T2)) +# define BOOST_PP_TE_167(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(166, T1), BOOST_PP_TUPLE_ELEM(166, T2)), BOOST_PP_TE_166(T1, T2)) +# define BOOST_PP_TE_168(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(167, T1), BOOST_PP_TUPLE_ELEM(167, T2)), BOOST_PP_TE_167(T1, T2)) +# define BOOST_PP_TE_169(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(168, T1), BOOST_PP_TUPLE_ELEM(168, T2)), BOOST_PP_TE_168(T1, T2)) +# define BOOST_PP_TE_170(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(169, T1), BOOST_PP_TUPLE_ELEM(169, T2)), BOOST_PP_TE_169(T1, T2)) +# define BOOST_PP_TE_171(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(170, T1), BOOST_PP_TUPLE_ELEM(170, T2)), BOOST_PP_TE_170(T1, T2)) +# define BOOST_PP_TE_172(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(171, T1), BOOST_PP_TUPLE_ELEM(171, T2)), BOOST_PP_TE_171(T1, T2)) +# define BOOST_PP_TE_173(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(172, T1), BOOST_PP_TUPLE_ELEM(172, T2)), BOOST_PP_TE_172(T1, T2)) +# define BOOST_PP_TE_174(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(173, T1), BOOST_PP_TUPLE_ELEM(173, T2)), BOOST_PP_TE_173(T1, T2)) +# define BOOST_PP_TE_175(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(174, T1), BOOST_PP_TUPLE_ELEM(174, T2)), BOOST_PP_TE_174(T1, T2)) +# define BOOST_PP_TE_176(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(175, T1), BOOST_PP_TUPLE_ELEM(175, T2)), BOOST_PP_TE_175(T1, T2)) +# define BOOST_PP_TE_177(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(176, T1), BOOST_PP_TUPLE_ELEM(176, T2)), BOOST_PP_TE_176(T1, T2)) +# define BOOST_PP_TE_178(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(177, T1), BOOST_PP_TUPLE_ELEM(177, T2)), BOOST_PP_TE_177(T1, T2)) +# define BOOST_PP_TE_179(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(178, T1), BOOST_PP_TUPLE_ELEM(178, T2)), BOOST_PP_TE_178(T1, T2)) +# define BOOST_PP_TE_180(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(179, T1), BOOST_PP_TUPLE_ELEM(179, T2)), BOOST_PP_TE_179(T1, T2)) +# define BOOST_PP_TE_181(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(180, T1), BOOST_PP_TUPLE_ELEM(180, T2)), BOOST_PP_TE_180(T1, T2)) +# define BOOST_PP_TE_182(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(181, T1), BOOST_PP_TUPLE_ELEM(181, T2)), BOOST_PP_TE_181(T1, T2)) +# define BOOST_PP_TE_183(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(182, T1), BOOST_PP_TUPLE_ELEM(182, T2)), BOOST_PP_TE_182(T1, T2)) +# define BOOST_PP_TE_184(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(183, T1), BOOST_PP_TUPLE_ELEM(183, T2)), BOOST_PP_TE_183(T1, T2)) +# define BOOST_PP_TE_185(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(184, T1), BOOST_PP_TUPLE_ELEM(184, T2)), BOOST_PP_TE_184(T1, T2)) +# define BOOST_PP_TE_186(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(185, T1), BOOST_PP_TUPLE_ELEM(185, T2)), BOOST_PP_TE_185(T1, T2)) +# define BOOST_PP_TE_187(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(186, T1), BOOST_PP_TUPLE_ELEM(186, T2)), BOOST_PP_TE_186(T1, T2)) +# define BOOST_PP_TE_188(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(187, T1), BOOST_PP_TUPLE_ELEM(187, T2)), BOOST_PP_TE_187(T1, T2)) +# define BOOST_PP_TE_189(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(188, T1), BOOST_PP_TUPLE_ELEM(188, T2)), BOOST_PP_TE_188(T1, T2)) +# define BOOST_PP_TE_190(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(189, T1), BOOST_PP_TUPLE_ELEM(189, T2)), BOOST_PP_TE_189(T1, T2)) +# define BOOST_PP_TE_191(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(190, T1), BOOST_PP_TUPLE_ELEM(190, T2)), BOOST_PP_TE_190(T1, T2)) +# define BOOST_PP_TE_192(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(191, T1), BOOST_PP_TUPLE_ELEM(191, T2)), BOOST_PP_TE_191(T1, T2)) +# define BOOST_PP_TE_193(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(192, T1), BOOST_PP_TUPLE_ELEM(192, T2)), BOOST_PP_TE_192(T1, T2)) +# define BOOST_PP_TE_194(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(193, T1), BOOST_PP_TUPLE_ELEM(193, T2)), BOOST_PP_TE_193(T1, T2)) +# define BOOST_PP_TE_195(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(194, T1), BOOST_PP_TUPLE_ELEM(194, T2)), BOOST_PP_TE_194(T1, T2)) +# define BOOST_PP_TE_196(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(195, T1), BOOST_PP_TUPLE_ELEM(195, T2)), BOOST_PP_TE_195(T1, T2)) +# define BOOST_PP_TE_197(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(196, T1), BOOST_PP_TUPLE_ELEM(196, T2)), BOOST_PP_TE_196(T1, T2)) +# define BOOST_PP_TE_198(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(197, T1), BOOST_PP_TUPLE_ELEM(197, T2)), BOOST_PP_TE_197(T1, T2)) +# define BOOST_PP_TE_199(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(198, T1), BOOST_PP_TUPLE_ELEM(198, T2)), BOOST_PP_TE_198(T1, T2)) +# define BOOST_PP_TE_200(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(199, T1), BOOST_PP_TUPLE_ELEM(199, T2)), BOOST_PP_TE_199(T1, T2)) +# define BOOST_PP_TE_201(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(200, T1), BOOST_PP_TUPLE_ELEM(200, T2)), BOOST_PP_TE_200(T1, T2)) +# define BOOST_PP_TE_202(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(201, T1), BOOST_PP_TUPLE_ELEM(201, T2)), BOOST_PP_TE_201(T1, T2)) +# define BOOST_PP_TE_203(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(202, T1), BOOST_PP_TUPLE_ELEM(202, T2)), BOOST_PP_TE_202(T1, T2)) +# define BOOST_PP_TE_204(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(203, T1), BOOST_PP_TUPLE_ELEM(203, T2)), BOOST_PP_TE_203(T1, T2)) +# define BOOST_PP_TE_205(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(204, T1), BOOST_PP_TUPLE_ELEM(204, T2)), BOOST_PP_TE_204(T1, T2)) +# define BOOST_PP_TE_206(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(205, T1), BOOST_PP_TUPLE_ELEM(205, T2)), BOOST_PP_TE_205(T1, T2)) +# define BOOST_PP_TE_207(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(206, T1), BOOST_PP_TUPLE_ELEM(206, T2)), BOOST_PP_TE_206(T1, T2)) +# define BOOST_PP_TE_208(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(207, T1), BOOST_PP_TUPLE_ELEM(207, T2)), BOOST_PP_TE_207(T1, T2)) +# define BOOST_PP_TE_209(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(208, T1), BOOST_PP_TUPLE_ELEM(208, T2)), BOOST_PP_TE_208(T1, T2)) +# define BOOST_PP_TE_210(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(209, T1), BOOST_PP_TUPLE_ELEM(209, T2)), BOOST_PP_TE_209(T1, T2)) +# define BOOST_PP_TE_211(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(210, T1), BOOST_PP_TUPLE_ELEM(210, T2)), BOOST_PP_TE_210(T1, T2)) +# define BOOST_PP_TE_212(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(211, T1), BOOST_PP_TUPLE_ELEM(211, T2)), BOOST_PP_TE_211(T1, T2)) +# define BOOST_PP_TE_213(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(212, T1), BOOST_PP_TUPLE_ELEM(212, T2)), BOOST_PP_TE_212(T1, T2)) +# define BOOST_PP_TE_214(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(213, T1), BOOST_PP_TUPLE_ELEM(213, T2)), BOOST_PP_TE_213(T1, T2)) +# define BOOST_PP_TE_215(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(214, T1), BOOST_PP_TUPLE_ELEM(214, T2)), BOOST_PP_TE_214(T1, T2)) +# define BOOST_PP_TE_216(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(215, T1), BOOST_PP_TUPLE_ELEM(215, T2)), BOOST_PP_TE_215(T1, T2)) +# define BOOST_PP_TE_217(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(216, T1), BOOST_PP_TUPLE_ELEM(216, T2)), BOOST_PP_TE_216(T1, T2)) +# define BOOST_PP_TE_218(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(217, T1), BOOST_PP_TUPLE_ELEM(217, T2)), BOOST_PP_TE_217(T1, T2)) +# define BOOST_PP_TE_219(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(218, T1), BOOST_PP_TUPLE_ELEM(218, T2)), BOOST_PP_TE_218(T1, T2)) +# define BOOST_PP_TE_220(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(219, T1), BOOST_PP_TUPLE_ELEM(219, T2)), BOOST_PP_TE_219(T1, T2)) +# define BOOST_PP_TE_221(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(220, T1), BOOST_PP_TUPLE_ELEM(220, T2)), BOOST_PP_TE_220(T1, T2)) +# define BOOST_PP_TE_222(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(221, T1), BOOST_PP_TUPLE_ELEM(221, T2)), BOOST_PP_TE_221(T1, T2)) +# define BOOST_PP_TE_223(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(222, T1), BOOST_PP_TUPLE_ELEM(222, T2)), BOOST_PP_TE_222(T1, T2)) +# define BOOST_PP_TE_224(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(223, T1), BOOST_PP_TUPLE_ELEM(223, T2)), BOOST_PP_TE_223(T1, T2)) +# define BOOST_PP_TE_225(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(224, T1), BOOST_PP_TUPLE_ELEM(224, T2)), BOOST_PP_TE_224(T1, T2)) +# define BOOST_PP_TE_226(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(225, T1), BOOST_PP_TUPLE_ELEM(225, T2)), BOOST_PP_TE_225(T1, T2)) +# define BOOST_PP_TE_227(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(226, T1), BOOST_PP_TUPLE_ELEM(226, T2)), BOOST_PP_TE_226(T1, T2)) +# define BOOST_PP_TE_228(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(227, T1), BOOST_PP_TUPLE_ELEM(227, T2)), BOOST_PP_TE_227(T1, T2)) +# define BOOST_PP_TE_229(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(228, T1), BOOST_PP_TUPLE_ELEM(228, T2)), BOOST_PP_TE_228(T1, T2)) +# define BOOST_PP_TE_230(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(229, T1), BOOST_PP_TUPLE_ELEM(229, T2)), BOOST_PP_TE_229(T1, T2)) +# define BOOST_PP_TE_231(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(230, T1), BOOST_PP_TUPLE_ELEM(230, T2)), BOOST_PP_TE_230(T1, T2)) +# define BOOST_PP_TE_232(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(231, T1), BOOST_PP_TUPLE_ELEM(231, T2)), BOOST_PP_TE_231(T1, T2)) +# define BOOST_PP_TE_233(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(232, T1), BOOST_PP_TUPLE_ELEM(232, T2)), BOOST_PP_TE_232(T1, T2)) +# define BOOST_PP_TE_234(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(233, T1), BOOST_PP_TUPLE_ELEM(233, T2)), BOOST_PP_TE_233(T1, T2)) +# define BOOST_PP_TE_235(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(234, T1), BOOST_PP_TUPLE_ELEM(234, T2)), BOOST_PP_TE_234(T1, T2)) +# define BOOST_PP_TE_236(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(235, T1), BOOST_PP_TUPLE_ELEM(235, T2)), BOOST_PP_TE_235(T1, T2)) +# define BOOST_PP_TE_237(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(236, T1), BOOST_PP_TUPLE_ELEM(236, T2)), BOOST_PP_TE_236(T1, T2)) +# define BOOST_PP_TE_238(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(237, T1), BOOST_PP_TUPLE_ELEM(237, T2)), BOOST_PP_TE_237(T1, T2)) +# define BOOST_PP_TE_239(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(238, T1), BOOST_PP_TUPLE_ELEM(238, T2)), BOOST_PP_TE_238(T1, T2)) +# define BOOST_PP_TE_240(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(239, T1), BOOST_PP_TUPLE_ELEM(239, T2)), BOOST_PP_TE_239(T1, T2)) +# define BOOST_PP_TE_241(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(240, T1), BOOST_PP_TUPLE_ELEM(240, T2)), BOOST_PP_TE_240(T1, T2)) +# define BOOST_PP_TE_242(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(241, T1), BOOST_PP_TUPLE_ELEM(241, T2)), BOOST_PP_TE_241(T1, T2)) +# define BOOST_PP_TE_243(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(242, T1), BOOST_PP_TUPLE_ELEM(242, T2)), BOOST_PP_TE_242(T1, T2)) +# define BOOST_PP_TE_244(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(243, T1), BOOST_PP_TUPLE_ELEM(243, T2)), BOOST_PP_TE_243(T1, T2)) +# define BOOST_PP_TE_245(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(244, T1), BOOST_PP_TUPLE_ELEM(244, T2)), BOOST_PP_TE_244(T1, T2)) +# define BOOST_PP_TE_246(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(245, T1), BOOST_PP_TUPLE_ELEM(245, T2)), BOOST_PP_TE_245(T1, T2)) +# define BOOST_PP_TE_247(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(246, T1), BOOST_PP_TUPLE_ELEM(246, T2)), BOOST_PP_TE_246(T1, T2)) +# define BOOST_PP_TE_248(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(247, T1), BOOST_PP_TUPLE_ELEM(247, T2)), BOOST_PP_TE_247(T1, T2)) +# define BOOST_PP_TE_249(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(248, T1), BOOST_PP_TUPLE_ELEM(248, T2)), BOOST_PP_TE_248(T1, T2)) +# define BOOST_PP_TE_250(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(249, T1), BOOST_PP_TUPLE_ELEM(249, T2)), BOOST_PP_TE_249(T1, T2)) +# define BOOST_PP_TE_251(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(250, T1), BOOST_PP_TUPLE_ELEM(250, T2)), BOOST_PP_TE_250(T1, T2)) +# define BOOST_PP_TE_252(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(251, T1), BOOST_PP_TUPLE_ELEM(251, T2)), BOOST_PP_TE_251(T1, T2)) +# define BOOST_PP_TE_253(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(252, T1), BOOST_PP_TUPLE_ELEM(252, T2)), BOOST_PP_TE_252(T1, T2)) +# define BOOST_PP_TE_254(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(253, T1), BOOST_PP_TUPLE_ELEM(253, T2)), BOOST_PP_TE_253(T1, T2)) +# define BOOST_PP_TE_255(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(254, T1), BOOST_PP_TUPLE_ELEM(254, T2)), BOOST_PP_TE_254(T1, T2)) +# define BOOST_PP_TE_256(T1, T2) BOOST_PP_BITAND(BOOST_PP_EQUAL(BOOST_PP_TUPLE_ELEM(255, T1), BOOST_PP_TUPLE_ELEM(255, T2)), BOOST_PP_TE_255(T1, T2)) + + + +# endif /* BOOST_PP_VARIADICS */ + +#endif /* !BOOST_PREPROCESSOR_TUPLE_EQUAL_HPP */ diff --git a/test/tuple.cxx b/test/tuple.cxx index 0f334f40..d0259f9f 100644 --- a/test/tuple.cxx +++ b/test/tuple.cxx @@ -263,4 +263,11 @@ BEGIN BOOST_PP_SEQ_ELEM(55,BOOST_PP_TUPLE_TO_SEQ(TUPLE_VERY_LARGE)) == 55 END BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0,BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE))) == 1 END BEGIN BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_TO_SEQ(TUPLE_NONE)) == 1 END +// equal + +BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE, TUPLE) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE, TUPLE_LARGE) == 0 END +BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE_LARGE, TUPLE) == 0 END +BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE_LARGE, TUPLE_LARGE) == 1 END + #endif From 34c7eb8babb0b5612f5469d13e4949123283ad4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 18:05:07 +0100 Subject: [PATCH 4/9] Added BOOST_PP_ARRAY_CAT and tests. --- include/boost/preprocessor/array.hpp | 1 + include/boost/preprocessor/array/cat.hpp | 46 ++++++++++++++++++++++++++++++++ test/array.cxx | 9 ++++++- 3 files changed, 55 insertions(+), 1 deletion(-) create mode 100644 include/boost/preprocessor/array/cat.hpp diff --git a/include/boost/preprocessor/array.hpp b/include/boost/preprocessor/array.hpp index 5bb6634c..cd49531a 100644 --- a/include/boost/preprocessor/array.hpp +++ b/include/boost/preprocessor/array.hpp @@ -13,6 +13,7 @@ # ifndef BOOST_PREPROCESSOR_ARRAY_HPP # define BOOST_PREPROCESSOR_ARRAY_HPP # +# include # include # include # include diff --git a/include/boost/preprocessor/array/cat.hpp b/include/boost/preprocessor/array/cat.hpp new file mode 100644 index 00000000..1023d7f3 --- /dev/null +++ b/include/boost/preprocessor/array/cat.hpp @@ -0,0 +1,46 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_ARRAY_CAT_HPP +# define BOOST_PREPROCESSOR_ARRAY_CAT_HPP + + + +# include +# include +# include +# include +# include +# include + + + +/* +** BOOST_PP_ARRAY_CAT +** Concatenates two PP_ARRAYs. +** _D variant uses the next available PP_WHILE iteration +*/ + +# define BOOST_PP_ARRAY_CAT( A1, A2) BOOST_PP_AC_1( BOOST_PP_WHILE(BOOST_PP_AC_PRED, BOOST_PP_AC_OP, (A1, A2))) +# define BOOST_PP_ARRAY_CAT_D(D, A1, A2) BOOST_PP_AC_1(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_AC_PRED, BOOST_PP_AC_OP, (A1, A2))) + + + +/* +** Internal helpers +*/ + +# define BOOST_PP_AC_1(S) BOOST_PP_TUPLE_ELEM(2, 0, S) +# define BOOST_PP_AC_2(S) BOOST_PP_TUPLE_ELEM(2, 1, S) +# define BOOST_PP_AC_PRED(D, S) BOOST_PP_ARRAY_SIZE(BOOST_PP_AC_2(S)) +# define BOOST_PP_AC_OP( D, S) (BOOST_PP_ARRAY_PUSH_BACK(BOOST_PP_AC_1(S), BOOST_PP_ARRAY_ELEM(0, BOOST_PP_AC_2(S))), BOOST_PP_ARRAY_POP_FRONT(BOOST_PP_AC_2(S))) + + + +#endif /* !BOOST_PREPROCESSOR_ARRAY_CAT_HPP */ diff --git a/test/array.cxx b/test/array.cxx index be5f7fc6..e5e5d57d 100644 --- a/test/array.cxx +++ b/test/array.cxx @@ -196,4 +196,11 @@ BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_ONE)) == 1 END BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_EMPTY, ARRAY_EMPTY) == 1 END BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_EMPTY, ARRAY_LARGE) == 0 END BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_LARGE, ARRAY_EMPTY) == 0 END -BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_LARGE, ARRAY_LARGE) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(ARRAY_VERY_LARGE, ARRAY_VERY_LARGE) == 1 END + +// cat + +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY_EMPTY, ARRAY_EMPTY), ARRAY_EMPTY) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY_EMPTY, ARRAY_LARGE), ARRAY_LARGE) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY_LARGE, ARRAY_EMPTY), ARRAY_LARGE) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY, ARRAY), (6, (0, 1, 2, 0, 1, 2))) == 1 END From 8dc47861bae33a79a6a9240c25a40cd1c0c86fab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 18:12:48 +0100 Subject: [PATCH 5/9] Added BOOST_PP_TUPLE_CAT and tests. --- include/boost/preprocessor/tuple.hpp | 1 + include/boost/preprocessor/tuple/cat.hpp | 52 ++++++++++++++++++++++++++++++++ test/tuple.cxx | 5 +++ 3 files changed, 58 insertions(+) create mode 100644 include/boost/preprocessor/tuple/cat.hpp diff --git a/include/boost/preprocessor/tuple.hpp b/include/boost/preprocessor/tuple.hpp index adbf30e5..3b86818e 100644 --- a/include/boost/preprocessor/tuple.hpp +++ b/include/boost/preprocessor/tuple.hpp @@ -15,6 +15,7 @@ # ifndef BOOST_PREPROCESSOR_TUPLE_HPP # define BOOST_PREPROCESSOR_TUPLE_HPP # +# include # include # include # include diff --git a/include/boost/preprocessor/tuple/cat.hpp b/include/boost/preprocessor/tuple/cat.hpp new file mode 100644 index 00000000..83d7cb8c --- /dev/null +++ b/include/boost/preprocessor/tuple/cat.hpp @@ -0,0 +1,52 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_TUPLE_CAT_HPP +# define BOOST_PREPROCESSOR_TUPLE_CAT_HPP + +# include +# if BOOST_PP_VARIADICS + + + +# include +# include +# include +# include +# include +# include + + + +/* +** BOOST_PP_TUPLE_CAT +** Concatenates two PP_TUPLEs. +** _D variant uses the next available PP_WHILE iteration +*/ + +# define BOOST_PP_TUPLE_CAT( A1, A2) BOOST_PP_TC_P( BOOST_PP_WHILE(BOOST_PP_TC_PRED, BOOST_PP_TC_OP, (A1, A2))) +# define BOOST_PP_TUPLE_CAT_D(D, A1, A2) BOOST_PP_TC_P(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_TC_PRED, BOOST_PP_TC_OP, (A1, A2))) + + + +/* +** Internal helpers +*/ + +# define BOOST_PP_TC_1(S) BOOST_PP_TUPLE_ELEM(0, S) +# define BOOST_PP_TC_2(S) BOOST_PP_TUPLE_ELEM(1, S) +# define BOOST_PP_TC_P(S) BOOST_PP_TUPLE_PUSH_BACK(BOOST_PP_TC_1(S), BOOST_PP_TUPLE_ELEM(0, BOOST_PP_TC_2(S))) +# define BOOST_PP_TC_PRED(D, S) BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(BOOST_PP_TC_2(S)), 1) +# define BOOST_PP_TC_OP( D, S) (BOOST_PP_TC_P(S), BOOST_PP_TUPLE_POP_FRONT(BOOST_PP_TC_2(S))) + + + +# endif /* BOOST_PP_VARIADICS */ + +#endif /* !BOOST_PREPROCESSOR_TUPLE_CAT_HPP */ diff --git a/test/tuple.cxx b/test/tuple.cxx index d0259f9f..7404711a 100644 --- a/test/tuple.cxx +++ b/test/tuple.cxx @@ -270,4 +270,9 @@ BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE, TUPLE_LARGE) == 0 END BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE_LARGE, TUPLE) == 0 END BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE_LARGE, TUPLE_LARGE) == 1 END +// cat + +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_CAT(TUPLE_LARGE, TUPLE), (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0, 1, 2, 3, 4, 5)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_CAT(TUPLE, TUPLE_LARGE), (0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32)) == 1 END + #endif From cb47a281479f7d0f0863ddfacca61c120732054e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 18:21:06 +0100 Subject: [PATCH 6/9] Added BOOST_PP_ARRAY_LOWER_BOUND and tests. --- include/boost/preprocessor/array.hpp | 1 + include/boost/preprocessor/array/lower_bound.hpp | 56 ++++++++++++++++++++++++ test/array.cxx | 30 +++++++++++++ 3 files changed, 87 insertions(+) create mode 100644 include/boost/preprocessor/array/lower_bound.hpp diff --git a/include/boost/preprocessor/array.hpp b/include/boost/preprocessor/array.hpp index cd49531a..fb392963 100644 --- a/include/boost/preprocessor/array.hpp +++ b/include/boost/preprocessor/array.hpp @@ -19,6 +19,7 @@ # include # include # include +# include # include # include # include diff --git a/include/boost/preprocessor/array/lower_bound.hpp b/include/boost/preprocessor/array/lower_bound.hpp new file mode 100644 index 00000000..4d9d6b04 --- /dev/null +++ b/include/boost/preprocessor/array/lower_bound.hpp @@ -0,0 +1,56 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_ARRAY_LOWER_BOUND_HPP +# define BOOST_PREPROCESSOR_ARRAY_LOWER_BOUND_HPP + + + +# include +# include +# include +# include +# include +# include +# include +# include +# include + + + +/* +** BOOST_PP_ARRAY_LOWER_BOUND +** Finds the lower bound of a given element in a given *sorted* PP_ARRAY. +** Return value is the index of the lower bound in the array. +** _D variants use the next available PP_WHILE iteration +*/ + +# define BOOST_PP_ARRAY_LOWER_BOUND( A, E) BOOST_PP_ALB_INDEX( BOOST_PP_WHILE(BOOST_PP_ALB_PRED, BOOST_PP_ALB_OP, (A, E, 0))) +# define BOOST_PP_ARRAY_LOWER_BOUND_D(D, A, E) BOOST_PP_ALB_INDEX(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_ALB_PRED, BOOST_PP_ALB_OP, (A, E, 0))) + + + +/* +** Internal helpers +*/ + +# define BOOST_PP_ALB_ARRAY_ELEM_IMPLEM(D, A, S, I) BOOST_PP_IF(BOOST_PP_LESS_D(D, I, S), BOOST_PP_ARRAY_ELEM, BOOST_PP_DISCARD_MAX_2)(I, A) + +# define BOOST_PP_ALB_ARRAY_ELEM(D, S) BOOST_PP_ALB_ARRAY_ELEM_IMPLEM(D, BOOST_PP_ALB_ARRAY(S), BOOST_PP_ALB_ARRAY_SIZE(S), BOOST_PP_ALB_INDEX(S)) +# define BOOST_PP_ALB_ARRAY_SIZE(S) BOOST_PP_ARRAY_SIZE(BOOST_PP_ALB_ARRAY(S)) +# define BOOST_PP_ALB_ARRAY(S) BOOST_PP_TUPLE_ELEM(3, 0, S) +# define BOOST_PP_ALB_BOUND(S) BOOST_PP_TUPLE_ELEM(3, 1, S) +# define BOOST_PP_ALB_INDEX(S) BOOST_PP_TUPLE_ELEM(3, 2, S) + +# define BOOST_PP_ALB_PRED(D, S) BOOST_PP_LESS_D(D, BOOST_PP_ALB_ARRAY_ELEM(D, S), BOOST_PP_ALB_BOUND(S)) +# define BOOST_PP_ALB_OP(D, S) (BOOST_PP_ALB_ARRAY(S), BOOST_PP_ALB_BOUND(S), BOOST_PP_INC(BOOST_PP_ALB_INDEX(S))) + + + +#endif /* !BOOST_PREPROCESSOR_ARRAY_LOWER_BOUND_HPP */ diff --git a/test/array.cxx b/test/array.cxx index e5e5d57d..fb5b3184 100644 --- a/test/array.cxx +++ b/test/array.cxx @@ -204,3 +204,33 @@ BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY_EMPTY, ARRAY_EMPTY), ARRAY_E BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY_EMPTY, ARRAY_LARGE), ARRAY_LARGE) == 1 END BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY_LARGE, ARRAY_EMPTY), ARRAY_LARGE) == 1 END BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_CAT(ARRAY, ARRAY), (6, (0, 1, 2, 0, 1, 2))) == 1 END + +// lower bound + +#define TEST_ALB_0 ( 0, ()) +#define TEST_ALB_1 ( 1, (1)) +#define TEST_ALB_2 ( 2, (1, 2)) +#define TEST_ALB_3 ( 3, (1, 2, 3)) +#define TEST_ALB_4 ( 3, (1, 1, 1)) + +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_0, 0) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_0, 1) == 0 END + +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_1, 0) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_1, 1) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_1, 2) == 1 END + +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_2, 0) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_2, 1) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_2, 2) == 1 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_2, 3) == 2 END + +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_3, 0) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_3, 1) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_3, 2) == 1 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_3, 3) == 2 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_3, 4) == 3 END + +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_4, 0) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_4, 1) == 0 END +BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_4, 2) == 3 END From fd518489f3dbfed917b19442b5e1e499bd7fda32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 18:23:41 +0100 Subject: [PATCH 7/9] Added BOOST_PP_TUPLE_LOWER_BOUND and tests. --- include/boost/preprocessor/tuple.hpp | 1 + include/boost/preprocessor/tuple/lower_bound.hpp | 60 ++++++++++++++++++++++++ test/tuple.cxx | 26 ++++++++++ 3 files changed, 87 insertions(+) create mode 100644 include/boost/preprocessor/tuple/lower_bound.hpp diff --git a/include/boost/preprocessor/tuple.hpp b/include/boost/preprocessor/tuple.hpp index 3b86818e..0b23cbce 100644 --- a/include/boost/preprocessor/tuple.hpp +++ b/include/boost/preprocessor/tuple.hpp @@ -21,6 +21,7 @@ # include # include # include +# include # include # include # include diff --git a/include/boost/preprocessor/tuple/lower_bound.hpp b/include/boost/preprocessor/tuple/lower_bound.hpp new file mode 100644 index 00000000..2341d5fe --- /dev/null +++ b/include/boost/preprocessor/tuple/lower_bound.hpp @@ -0,0 +1,60 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_TUPLE_LOWER_BOUND_HPP +# define BOOST_PREPROCESSOR_TUPLE_LOWER_BOUND_HPP + +# include +# if BOOST_PP_VARIADICS + + + +# include +# include +# include +# include +# include +# include +# include +# include + + + +/* +** BOOST_PP_TUPLE_LOWER_BOUND +** Finds the lower bound of a given element in a given *sorted* PP_TUPLE. +** Return value is the index of the lower bound in the tuple. +** _D variants use the next available PP_WHILE iteration +*/ + +# define BOOST_PP_TUPLE_LOWER_BOUND(A, E) BOOST_PP_TLB_INDEX( BOOST_PP_WHILE(BOOST_PP_TLB_PRED, BOOST_PP_TLB_OP, (A, E, 0))) +# define BOOST_PP_TUPLE_LOWER_BOUND_D(D, A, E) BOOST_PP_TLB_INDEX(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_TLB_PRED, BOOST_PP_TLB_OP, (A, E, 0))) + + + +/* +** Internal helpers +*/ + +# define BOOST_PP_TLB_TUPLE_ELEM_IMPLEM(D, A, S, I) BOOST_PP_IF(BOOST_PP_LESS_D(D, I, S), BOOST_PP_TUPLE_ELEM, BOOST_PP_DISCARD_MAX_2)(I, A) + +# define BOOST_PP_TLB_TUPLE_ELEM(D, S) BOOST_PP_TLB_TUPLE_ELEM_IMPLEM(D, BOOST_PP_TLB_TUPLE(S), BOOST_PP_TLB_TUPLE_SIZE(S), BOOST_PP_TLB_INDEX(S)) +# define BOOST_PP_TLB_TUPLE_SIZE(S) BOOST_PP_TUPLE_SIZE(BOOST_PP_TLB_TUPLE(S)) +# define BOOST_PP_TLB_TUPLE(S) BOOST_PP_TUPLE_ELEM(3, 0, S) +# define BOOST_PP_TLB_BOUND(S) BOOST_PP_TUPLE_ELEM(3, 1, S) +# define BOOST_PP_TLB_INDEX(S) BOOST_PP_TUPLE_ELEM(3, 2, S) + +# define BOOST_PP_TLB_PRED(D, S) BOOST_PP_LESS_D(D, BOOST_PP_TLB_TUPLE_ELEM(D, S), BOOST_PP_TLB_BOUND(S)) +# define BOOST_PP_TLB_OP(D, S) (BOOST_PP_TLB_TUPLE(S), BOOST_PP_TLB_BOUND(S), BOOST_PP_INC(BOOST_PP_TLB_INDEX(S))) + + + +# endif /* BOOST_PP_VARIADICS */ + +#endif /* !BOOST_PREPROCESSOR_TUPLE_LOWER_BOUND_HPP */ diff --git a/test/tuple.cxx b/test/tuple.cxx index 7404711a..95ff812d 100644 --- a/test/tuple.cxx +++ b/test/tuple.cxx @@ -275,4 +275,30 @@ BEGIN BOOST_PP_TUPLE_EQUAL(TUPLE_LARGE, TUPLE_LARGE) == 1 END BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_CAT(TUPLE_LARGE, TUPLE), (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 0, 1, 2, 3, 4, 5)) == 1 END BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_CAT(TUPLE, TUPLE_LARGE), (0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32)) == 1 END +// lower bound + +#define TEST_TLB_1 (1) +#define TEST_TLB_2 (1, 2) +#define TEST_TLB_3 (1, 2, 3) +#define TEST_TLB_4 (1, 1, 1) + +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_1, 0) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_1, 1) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_1, 2) == 1 END + +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_2, 0) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_2, 1) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_2, 2) == 1 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_2, 3) == 2 END + +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_3, 0) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_3, 1) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_3, 2) == 1 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_3, 3) == 2 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_3, 4) == 3 END + +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_4, 0) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_4, 1) == 0 END +BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_4, 2) == 3 END + #endif From c7e1293d956ebd591091c11ce85aacdd01f878ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 18:26:12 +0100 Subject: [PATCH 8/9] Added BOOST_PP_ARRAY_SORT and tests. --- include/boost/preprocessor/array.hpp | 1 + include/boost/preprocessor/array/sort.hpp | 66 +++++++++++++++++++++++++++++++ test/array.cxx | 22 +++++++++++ 3 files changed, 89 insertions(+) create mode 100644 include/boost/preprocessor/array/sort.hpp diff --git a/include/boost/preprocessor/array.hpp b/include/boost/preprocessor/array.hpp index fb392963..1cb4d689 100644 --- a/include/boost/preprocessor/array.hpp +++ b/include/boost/preprocessor/array.hpp @@ -28,6 +28,7 @@ # include # include # include +# include # include # include # include diff --git a/include/boost/preprocessor/array/sort.hpp b/include/boost/preprocessor/array/sort.hpp new file mode 100644 index 00000000..d50011ba --- /dev/null +++ b/include/boost/preprocessor/array/sort.hpp @@ -0,0 +1,66 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_ARRAY_SORT_HPP +# define BOOST_PREPROCESSOR_ARRAY_SORT_HPP + + + +# include +# include + + + +/* +** BOOST_PP_ARRAY_SORT +** Sorts the given PP_ARRAY. +** _U variants remove duplicates. +** _D variants use the next available PP_WHILE iteration +*/ + +# define BOOST_PP_ARRAY_SORT(A) BOOST_PP_AS_RES(BOOST_PP_WHILE( BOOST_PP_AS_PRED, BOOST_PP_AS_OP, (A, 0, (0, ())))) +# define BOOST_PP_ARRAY_SORT_U(A) BOOST_PP_AS_RES(BOOST_PP_WHILE( BOOST_PP_AS_PRED, BOOST_PP_AS_OP_U, (A, 0, (0, ())))) +# define BOOST_PP_ARRAY_SORT_D(D, A) BOOST_PP_AS_RES(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_AS_PRED, BOOST_PP_AS_OP, (A, 0, (0, ())))) +# define BOOST_PP_ARRAY_SORT_U_D(D, A) BOOST_PP_AS_RES(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_AS_PRED, BOOST_PP_AS_OP_U, (A, 0, (0, ())))) + + + +/* +** Boost 1.49.0 compatibility +*/ + +# ifndef BOOST_PP_TUPLE_REM_0 +# define BOOST_PP_TUPLE_REM_0() +# endif + + + +/* +** Internal helpers +*/ + +# define BOOST_PP_AS_LB(D, S) BOOST_PP_ARRAY_LOWER_BOUND_D(D, BOOST_PP_AS_RES(S), BOOST_PP_AS_ARRAY_ELEM(S)) + +# define BOOST_PP_AS_ARRAY_ELEM(S) BOOST_PP_ARRAY_ELEM(BOOST_PP_AS_INDEX(S), BOOST_PP_AS_ARRAY(S)) +# define BOOST_PP_AS_ARRAY_SIZE(S) BOOST_PP_ARRAY_SIZE(BOOST_PP_AS_ARRAY(S)) +# define BOOST_PP_AS_ARRAY(S) BOOST_PP_TUPLE_ELEM(3, 0, S) +# define BOOST_PP_AS_INDEX(S) BOOST_PP_TUPLE_ELEM(3, 1, S) +# define BOOST_PP_AS_RES(S) BOOST_PP_TUPLE_ELEM(3, 2, S) + +# define BOOST_PP_AS_MERGE( D, E, R, P) BOOST_PP_ARRAY_INSERT_D(D, R, P, E) +# define BOOST_PP_AS_MERGE_R(D, E, R, P) BOOST_PP_IF(BOOST_PP_LESS(E, BOOST_PP_ARRAY_ELEM(P, R)), BOOST_PP_AS_MERGE(D, E, R, P), R) +# define BOOST_PP_AS_MERGE_U(D, E, R, P) BOOST_PP_IF(BOOST_PP_LESS(P, BOOST_PP_ARRAY_SIZE(R)), BOOST_PP_AS_MERGE_R, BOOST_PP_AS_MERGE)(D, E, R, P) + +# define BOOST_PP_AS_PRED(D, S) BOOST_PP_LESS_D(D, BOOST_PP_AS_INDEX(S), BOOST_PP_AS_ARRAY_SIZE(S)) +# define BOOST_PP_AS_OP( D, S) (BOOST_PP_AS_ARRAY(S), BOOST_PP_INC(BOOST_PP_AS_INDEX(S)), BOOST_PP_AS_MERGE (D, BOOST_PP_AS_ARRAY_ELEM(S), BOOST_PP_AS_RES(S), BOOST_PP_AS_LB(D, S))) +# define BOOST_PP_AS_OP_U(D, S) (BOOST_PP_AS_ARRAY(S), BOOST_PP_INC(BOOST_PP_AS_INDEX(S)), BOOST_PP_AS_MERGE_U(D, BOOST_PP_AS_ARRAY_ELEM(S), BOOST_PP_AS_RES(S), BOOST_PP_AS_LB(D, S))) + + + +#endif /* !BOOST_PREPROCESSOR_ARRAY_SORT_HPP */ diff --git a/test/array.cxx b/test/array.cxx index fb5b3184..9988b94a 100644 --- a/test/array.cxx +++ b/test/array.cxx @@ -234,3 +234,25 @@ BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_3, 4) == 3 END BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_4, 0) == 0 END BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_4, 1) == 0 END BEGIN BOOST_PP_ARRAY_LOWER_BOUND(TEST_ALB_4, 2) == 3 END + +// sort + +#define TEST_AS_0 ( 1, (1)) +#define TEST_AS_1 ( 2, (1, 2)) +#define TEST_AS_2 ( 2, (2, 1)) +#define TEST_AS_3 ( 2, (2, 2)) +#define TEST_AS_4 (12, (2, 1, 1, 4, 3, 5, 12, 6, 0, 4, 5, 3)) +#define TEST_AS_5 ( 0, ()) + +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT(TEST_AS_0), (1, (1))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT(TEST_AS_1), (2, (1, 2))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT(TEST_AS_2), (2, (1, 2))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT(TEST_AS_3), (2, (2, 2))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT(TEST_AS_4), (12, (0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 12))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT(TEST_AS_5), (0, ())) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT_U(TEST_AS_0), (1, (1))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT_U(TEST_AS_1), (2, (1, 2))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT_U(TEST_AS_2), (2, (1, 2))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT_U(TEST_AS_3), (1, (2))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT_U(TEST_AS_4), (8, (0, 1, 2, 3, 4, 5, 6, 12))) == 1 END +BEGIN BOOST_PP_ARRAY_EQUAL(BOOST_PP_ARRAY_SORT_U(TEST_AS_5), (0, ())) == 1 END From 25337419707644d244abeb37152eb6d7028f2c64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicuv=C3=ABo?= Date: Sat, 12 Sep 2015 18:28:04 +0100 Subject: [PATCH 9/9] Added BOOST_PP_TUPLE_SORT and tests. --- include/boost/preprocessor/tuple.hpp | 1 + include/boost/preprocessor/tuple/sort.hpp | 72 +++++++++++++++++++++++++++++++ test/tuple.cxx | 19 ++++++++ 3 files changed, 92 insertions(+) create mode 100644 include/boost/preprocessor/tuple/sort.hpp diff --git a/include/boost/preprocessor/tuple.hpp b/include/boost/preprocessor/tuple.hpp index 0b23cbce..b60935b7 100644 --- a/include/boost/preprocessor/tuple.hpp +++ b/include/boost/preprocessor/tuple.hpp @@ -31,6 +31,7 @@ # include # include # include +# include # include # include # include diff --git a/include/boost/preprocessor/tuple/sort.hpp b/include/boost/preprocessor/tuple/sort.hpp new file mode 100644 index 00000000..acd37534 --- /dev/null +++ b/include/boost/preprocessor/tuple/sort.hpp @@ -0,0 +1,72 @@ +// +// Copyright Antoine Leblanc 2015 +// http://nauths.fr +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_PREPROCESSOR_TUPLE_SORT_HPP +# define BOOST_PREPROCESSOR_TUPLE_SORT_HPP + +# include +# if BOOST_PP_VARIADICS + + + +# include +# include + + + +/* +** BOOST_PP_TUPLE_SORT +** Sorts the given PP_TUPLE. +** _U variants remove duplicates. +** _D variants use the next available PP_WHILE iteration +*/ + +# define BOOST_PP_TUPLE_SORT(A) BOOST_PP_TS_RES(BOOST_PP_WHILE( BOOST_PP_TS_PRED, BOOST_PP_TS_OP, (A, 0, (0, (0))))) +# define BOOST_PP_TUPLE_SORT_U(A) BOOST_PP_TS_RES(BOOST_PP_WHILE( BOOST_PP_TS_PRED, BOOST_PP_TS_OP_U, (A, 0, (0, (0))))) +# define BOOST_PP_TUPLE_SORT_D(D, A) BOOST_PP_TS_RES(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_TS_PRED, BOOST_PP_TS_OP, (A, 0, (0, (0))))) +# define BOOST_PP_TUPLE_SORT_U_D(D, A) BOOST_PP_TS_RES(BOOST_PP_CAT(BOOST_PP_WHILE_, D)(BOOST_PP_TS_PRED, BOOST_PP_TS_OP_U, (A, 0, (0, (0))))) + + + +/* +** Boost 1.49.0 compatibility +*/ + +# ifndef BOOST_PP_TUPLE_REM_0 +# define BOOST_PP_TUPLE_REM_0() +# endif + + + +/* +** Internal helpers +*/ + +# define BOOST_PP_TS_LB(D, S) BOOST_PP_ARRAY_LOWER_BOUND_D(D, BOOST_PP_TS_OUT(S), BOOST_PP_TS_TUPLE_ELEM(S)) + +# define BOOST_PP_TS_TUPLE_ELEM(S) BOOST_PP_TUPLE_ELEM(BOOST_PP_TS_INDEX(S), BOOST_PP_TS_TUPLE(S)) +# define BOOST_PP_TS_TUPLE_SIZE(S) BOOST_PP_TUPLE_SIZE(BOOST_PP_TS_TUPLE(S)) +# define BOOST_PP_TS_TUPLE(S) BOOST_PP_TUPLE_ELEM(3, 0, S) +# define BOOST_PP_TS_INDEX(S) BOOST_PP_TUPLE_ELEM(3, 1, S) +# define BOOST_PP_TS_OUT(S) BOOST_PP_TUPLE_ELEM(3, 2, S) +# define BOOST_PP_TS_RES(S) BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_TS_OUT(S)) + +# define BOOST_PP_TS_MERGE( D, E, R, P) BOOST_PP_ARRAY_INSERT_D(D, R, P, E) +# define BOOST_PP_TS_MERGE_R(D, E, R, P) BOOST_PP_IF(BOOST_PP_LESS(E, BOOST_PP_ARRAY_ELEM(P, R)), BOOST_PP_TS_MERGE(D, E, R, P), R) +# define BOOST_PP_TS_MERGE_U(D, E, R, P) BOOST_PP_IF(BOOST_PP_LESS(P, BOOST_PP_ARRAY_SIZE(R)), BOOST_PP_TS_MERGE_R, BOOST_PP_TS_MERGE)(D, E, R, P) + +# define BOOST_PP_TS_PRED(D, S) BOOST_PP_LESS_D(D, BOOST_PP_TS_INDEX(S), BOOST_PP_TS_TUPLE_SIZE(S)) +# define BOOST_PP_TS_OP( D, S) (BOOST_PP_TS_TUPLE(S), BOOST_PP_INC(BOOST_PP_TS_INDEX(S)), BOOST_PP_TS_MERGE (D, BOOST_PP_TS_TUPLE_ELEM(S), BOOST_PP_TS_OUT(S), BOOST_PP_TS_LB(D, S))) +# define BOOST_PP_TS_OP_U(D, S) (BOOST_PP_TS_TUPLE(S), BOOST_PP_INC(BOOST_PP_TS_INDEX(S)), BOOST_PP_TS_MERGE_U(D, BOOST_PP_TS_TUPLE_ELEM(S), BOOST_PP_TS_OUT(S), BOOST_PP_TS_LB(D, S))) + + + +# endif /* BOOST_PP_VARIADICS */ + +#endif /* !BOOST_PREPROCESSOR_TUPLE_SORT_HPP */ diff --git a/test/tuple.cxx b/test/tuple.cxx index 95ff812d..5fc9d1a2 100644 --- a/test/tuple.cxx +++ b/test/tuple.cxx @@ -301,4 +301,23 @@ BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_4, 0) == 0 END BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_4, 1) == 0 END BEGIN BOOST_PP_TUPLE_LOWER_BOUND(TEST_TLB_4, 2) == 3 END +// tuple sort + +#define TEST_TS_0 (1) +#define TEST_TS_1 (1, 2) +#define TEST_TS_2 (2, 1) +#define TEST_TS_3 (2, 2) +#define TEST_TS_4 (2, 1, 1, 4, 3, 5, 12, 6, 0, 4, 5, 3) + +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT(TEST_TS_0), (1)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT(TEST_TS_1), (1, 2)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT(TEST_TS_2), (1, 2)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT(TEST_TS_3), (2, 2)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT(TEST_TS_4), (0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 12)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT_U(TEST_TS_0), (1)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT_U(TEST_TS_1), (1, 2)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT_U(TEST_TS_2), (1, 2)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT_U(TEST_TS_3), (2)) == 1 END +BEGIN BOOST_PP_TUPLE_EQUAL(BOOST_PP_TUPLE_SORT_U(TEST_TS_4), (0, 1, 2, 3, 4, 5, 6, 12)) == 1 END + #endif