1 // -*- c++ -*-
2 //*****************************************************************************
3 /** @file DegLexOrderTest.cc
4 *
5 * @author Ket Shcherbakova, Alexander Dreyer
6 * @date 2010-12-07
7 *
8 * boost/test-driven unit test
9 *
10 * @par Copyright:
11 * (c) 2010 by The PolyBoRi Team
12 *
13 **/
14 //*****************************************************************************
15
16
17 #include <boost/test/unit_test.hpp>
18 #include <boost/version.hpp>
19 #if BOOST_VERSION < 107100
20 #include <boost/test/output_test_stream.hpp>
21 #else
22 #include <boost/test/tools/output_test_stream.hpp>
23 #endif
24
25 using boost::test_tools::output_test_stream;
26
27 #include <polybori/DegLexOrder.h>
28
29 USING_NAMESPACE_PBORI
30
31 class Fdeglex {
32 public:
33 typedef DegLexOrder order_type;
Fdeglex(const BoolePolyRing & input_ring=BoolePolyRing (5,COrderEnums::lp))34 Fdeglex(const BoolePolyRing& input_ring =
35 BoolePolyRing(5, COrderEnums::lp)):
36 ring(input_ring),
37 x(0, input_ring), y(1, input_ring), z(2, input_ring),
38 v(3, input_ring), w(4, input_ring) {
39
40 BOOST_TEST_MESSAGE( "setup fixture" );
41 ring.setVariableName(0, "x");
42 ring.setVariableName(1, "y");
43 ring.setVariableName(2, "z");
44 ring.setVariableName(3, "v");
45 ring.setVariableName(4, "w");
46 }
~Fdeglex()47 ~Fdeglex() { BOOST_TEST_MESSAGE( "teardown fixture" ); }
48
49 BoolePolyRing ring;
50 BooleVariable x, y, z, v, w;
51 };
52
BOOST_FIXTURE_TEST_SUITE(DegLexOrderTestSuite,Fdeglex)53 BOOST_FIXTURE_TEST_SUITE(DegLexOrderTestSuite, Fdeglex )
54
55 BOOST_AUTO_TEST_CASE(test_properties) {
56
57 order_type order;
58 BOOST_TEST_MESSAGE( "isLexicographical, isSymmetric, isDegreeOrder, isBlockOrder, isTotalDegreeOrder, isDegreeReverseLexicographical, ascendingVariables, descendingVariables, orderedStandardIteration" );
59 BOOST_CHECK(!order.isLexicographical());
60 BOOST_CHECK(order.isSymmetric());
61 BOOST_CHECK(order.isDegreeOrder());
62 BOOST_CHECK(!order.isBlockOrder());
63 BOOST_CHECK(order.isTotalDegreeOrder());
64 BOOST_CHECK(!order.isDegreeReverseLexicographical());
65 BOOST_CHECK(!order.ascendingVariables());
66 BOOST_CHECK(order.descendingVariables());
67 BOOST_CHECK(!order.orderedStandardIteration());
68 }
69
BOOST_AUTO_TEST_CASE(test_getters)70 BOOST_AUTO_TEST_CASE(test_getters) {
71
72 order_type order;
73 BOOST_TEST_MESSAGE( "getOrderCode, getBaseOrderCode" );
74 BOOST_CHECK_EQUAL(order.getOrderCode(), COrderEnums::dlex);
75 BOOST_CHECK_EQUAL(order.getBaseOrderCode(), COrderEnums::dlex);
76 }
77
BOOST_AUTO_TEST_CASE(test_compare)78 BOOST_AUTO_TEST_CASE(test_compare) {
79
80 order_type order;
81 BOOST_TEST_MESSAGE( "compare" );
82 BooleMonomial monom1 = x;
83 BooleMonomial monom2 = x*x;
84 BOOST_CHECK_EQUAL(order.compare(monom1, monom2) , CTypes::equality);
85 monom1 = x*y;
86 monom2 = x*z*v;
87 BOOST_CHECK_EQUAL(order.compare(monom1, monom2) , CTypes::less_than);
88 monom1 = v*y;
89 monom2 = x;
90 BOOST_CHECK_EQUAL(order.compare(monom1, monom2) , CTypes::greater_than);
91 monom1 = BooleMonomial(ring);
92 monom2 = w;
93 BOOST_CHECK_EQUAL(order.compare(monom1, monom2) , CTypes::less_than);
94 monom1 = BooleMonomial(ring);
95 monom2 = BooleMonomial(ring);
96 BOOST_CHECK_EQUAL(order.compare(monom1, monom2) , CTypes::equality);
97 BooleExponent exp1(x);
98 BooleExponent exp2(x*x);
99 BOOST_CHECK_EQUAL(order.compare(exp1, exp2) , CTypes::equality);
100 exp1 = BooleExponent(w*x);
101 exp2 = BooleExponent(v*x);
102 BOOST_CHECK_EQUAL(order.compare(exp1, exp2) , CTypes::less_than);
103 exp1 = BooleExponent(x*y*z*v*w);
104 exp2 = BooleExponent(x*y*z*v);
105 BOOST_CHECK_EQUAL(order.compare(exp1, exp2) , CTypes::greater_than);
106 BOOST_CHECK_EQUAL(order.compare(0,1) , CTypes::greater_than);
107 BOOST_CHECK_EQUAL(order.compare(2,1) , CTypes::less_than);
108 BOOST_CHECK_EQUAL(order.compare(-1,-1) , CTypes::equality);
109 BOOST_CHECK_EQUAL(order.compare(1,-1) , CTypes::less_than);
110 }
111
BOOST_AUTO_TEST_CASE(test_lead)112 BOOST_AUTO_TEST_CASE(test_lead) {
113
114 BOOST_TEST_MESSAGE( "lead, leadExp, leadFirst" );
115 order_type order;
116 BoolePolynomial poly = x + x*y + y*z*v*w + 1;
117
118 // testing leadexp first, since they do not cache results (but call the cache)
119 BOOST_CHECK_EQUAL(order.leadExp(poly) , BooleExponent(y*z*v*w));
120 BOOST_CHECK_EQUAL(order.leadExp(poly,-1), BooleExponent());
121 BOOST_CHECK_EQUAL(order.leadExp(poly,0), BooleExponent());
122 BOOST_CHECK_EQUAL(order.leadExp(poly-1,0), BooleExponent());
123 BOOST_CHECK_EQUAL(order.leadExp(poly,1), BooleExponent(x));
124 BOOST_CHECK_EQUAL(order.leadExp(x + y, 0), BooleExponent());
125
126 BOOST_CHECK_EQUAL(order.lead(poly) , BooleMonomial(y*z*v*w));
127 BOOST_CHECK_EQUAL(order.lead(poly,1), BooleMonomial(x));
128 BOOST_CHECK_EQUAL(order.lead(poly,0), BooleMonomial(ring));
129
130 BOOST_CHECK_THROW(order.lead(x + y, 0), PBoRiError);
131 BOOST_CHECK_THROW(order.lead(poly,-1), PBoRiError);
132
133 poly = x + x*y + y + 1;
134 BOOST_CHECK_EQUAL(order.leadExp(poly), BooleExponent(x*y));
135 BOOST_CHECK_EQUAL(order.leadExp(poly,-1), BooleExponent());
136 BOOST_CHECK_EQUAL(order.leadExp(poly,1), BooleExponent(x));
137
138 BOOST_CHECK_EQUAL(order.lead(poly), BooleMonomial(x*y));
139 BOOST_CHECK_EQUAL(order.lead(poly, 1), BooleMonomial(x));
140 BOOST_CHECK_THROW(order.lead(poly, -1), PBoRiError);
141
142 // Empty (zero) poly
143 poly = BoolePolynomial(ring);
144 BOOST_CHECK_THROW(order.lead(poly), PBoRiGenericError<CTypes::illegal_on_zero>);
145 BOOST_CHECK_THROW(order.lead(poly,1), PBoRiGenericError<CTypes::illegal_on_zero>);
146 BOOST_CHECK_THROW(order.lead(poly),PBoRiGenericError<CTypes::illegal_on_zero>);
147 BOOST_CHECK_EQUAL(order.leadExp(poly,1), BooleExponent());
148 BOOST_CHECK_EQUAL(order.leadExp(poly,0), BooleExponent());
149 BOOST_CHECK_EQUAL(order.leadExp(poly), BooleExponent());
150 BOOST_CHECK_THROW(order.leadFirst(poly),PBoRiGenericError<CTypes::illegal_on_zero>);
151 poly = 1;
152 BOOST_CHECK_EQUAL(order.lead(poly, 1), BooleMonomial(ring));
153 BOOST_CHECK_EQUAL(order.lead(poly), BooleMonomial(ring));
154 BOOST_CHECK_EQUAL(order.leadExp(poly, 1), BooleExponent());
155 BOOST_CHECK_EQUAL(order.leadExp(poly), BooleExponent());
156 BOOST_CHECK_EQUAL(order.leadFirst(poly), poly);
157 poly = x*w + x*z + w*v*y;
158 BOOST_CHECK_THROW(order.lead(poly, 0), PBoRiError);
159 BOOST_CHECK_THROW(order.lead(poly, 0), std::exception);
160
161 BOOST_CHECK_EQUAL(order.leadExp(poly,0), BooleExponent());
162 poly=y;
163 BOOST_CHECK_EQUAL(order.lead(poly,1), BooleMonomial(y));
164 BOOST_CHECK_EQUAL(order.lead(poly,2), BooleMonomial(y));
165 BOOST_CHECK_THROW(order.lead(poly,-1), std::exception);
166 BOOST_CHECK_EQUAL(order.leadExp(poly,1), BooleExponent(y));
167 BOOST_CHECK_EQUAL(order.leadExp(poly,2), BooleExponent(y));
168 BOOST_CHECK_EQUAL(order.leadExp(poly,-1), BooleExponent());
169 BooleMonomial leadterm = z*v*w;
170 poly = x*y + x*v + leadterm;
171
172 BOOST_CHECK_EQUAL(order.lead(poly, 3), BooleMonomial(leadterm));
173 BOOST_CHECK_EQUAL(order.leadExp(poly,3), BooleExponent(leadterm));
174 BOOST_CHECK_EQUAL(poly, x*y + x*v + z*v*w);
175
176 BOOST_CHECK_THROW(order.lead(poly, 1), PBoRiError);
177 BOOST_CHECK_EQUAL(order.lead(poly, 2), x*y);
178 BOOST_CHECK_EQUAL(order.lead(poly, 3), z*v*w);
179 BOOST_CHECK_THROW(order.lead(poly, -1), PBoRiError);
180 BOOST_CHECK_EQUAL(order.leadExp(poly, 1), BooleExponent());
181 BOOST_CHECK_EQUAL(order.leadExp(poly, 2), (x*y).exp());
182 BOOST_CHECK_EQUAL(order.leadExp(poly, 3), (z*v*w).exp());
183 BOOST_CHECK_THROW(order.lead(poly,1), std::exception);
184 BOOST_CHECK_EQUAL(order.lead(poly,2), BooleMonomial(x*y));
185 BOOST_CHECK_EQUAL(order.lead(poly,3), leadterm);
186 BOOST_CHECK_THROW(order.lead(poly,-1), std::exception);
187 BOOST_CHECK_EQUAL(order.leadExp(poly,1), BooleExponent());
188 BOOST_CHECK_EQUAL(order.leadExp(poly,2), BooleExponent(x*y));
189 BOOST_CHECK_EQUAL(order.leadExp(poly,3), BooleExponent(leadterm));
190 BOOST_CHECK_EQUAL(order.leadExp(poly,-1), BooleExponent());
191 poly += y;
192 BOOST_CHECK_EQUAL(order.lead(poly,1), BooleMonomial(y));// Even as valid term y exists
193 BOOST_CHECK_EQUAL(order.lead(poly,2), BooleMonomial(x*y));
194 BOOST_CHECK_EQUAL(order.lead(poly,3), leadterm);
195 BOOST_CHECK_THROW(order.lead(poly,-1), std::exception);
196 BOOST_CHECK_EQUAL(order.leadExp(poly,1), BooleExponent(y));// Even as valid term y exists
197 BOOST_CHECK_EQUAL(order.leadExp(poly,2), BooleExponent(x*y));
198 BOOST_CHECK_EQUAL(order.leadExp(poly,3), BooleExponent(leadterm));
199 BOOST_CHECK_EQUAL(order.leadExp(poly,-1), BooleExponent());
200 }
201
BOOST_AUTO_TEST_CASE(test_blocks)202 BOOST_AUTO_TEST_CASE(test_blocks) {
203
204 BOOST_TEST_MESSAGE( "blockBegin, blockEnd, appendBlock, clearBlocks, lastBlockStart, lieInSameBlock" );
205 order_type order;
206 output_test_stream output;
207 BoolePolyRing::block_iterator start(order.blockBegin()),finish(order.blockEnd());
208 while (start != finish) {
209 output << *start <<", ";
210 ++start;
211 }
212 BOOST_CHECK(output.is_equal(""));
213 BOOST_CHECK_THROW(order.appendBlock(-1), std::exception);
214 order.appendBlock(0);
215 order.appendBlock(2);
216 order.appendBlock(6);
217 start = order.blockBegin();
218 finish = order.blockEnd();
219 while (start != finish) {
220 output << *start <<", ";
221 ++start;
222 }
223 BOOST_CHECK(output.is_equal(""));
224 BOOST_CHECK(order.lieInSameBlock(0,1));
225 BOOST_CHECK(order.lieInSameBlock(-1,4));
226 BOOST_CHECK_EQUAL(order.lastBlockStart(), 0);
227 order.clearBlocks();
228 start = order.blockBegin();
229 finish = order.blockEnd();
230 BOOST_CHECK(start==finish);
231 }
232
233
BOOST_AUTO_TEST_CASE(test_cover_constructors_and_destructors)234 BOOST_AUTO_TEST_CASE(test_cover_constructors_and_destructors) {
235 int order_code = CTypes::dlex;
236 BoolePolyRing block_ring(5, order_code);
237
238 BOOST_CHECK_EQUAL(block_ring.ordering().getOrderCode(), order_code);
239
240 class Inherited: public order_type {};
241
242 Inherited dummy;
243 BOOST_CHECK_EQUAL(dummy.getOrderCode(), order_code);
244
245 order_type self;
246 BOOST_CHECK_EQUAL(self.getOrderCode(), order_code);
247
248 order_type* pSelf = new order_type;
249 BOOST_CHECK_EQUAL(pSelf->getOrderCode(), order_code);
250 delete pSelf;
251
252 pSelf = new Inherited;
253 BOOST_CHECK_EQUAL(pSelf->getOrderCode(), order_code);
254 delete pSelf;
255
256 Inherited* pDummy = new Inherited;
257 BOOST_CHECK_EQUAL(pDummy->getOrderCode(), order_code);
258 delete pDummy;
259 }
260
261 BOOST_AUTO_TEST_SUITE_END()
262