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