PolyBoRi
|
00001 // -*- c++ -*- 00002 //***************************************************************************** 00157 //***************************************************************************** 00158 00159 #ifndef BooleMonomial_h_ 00160 #define BooleMonomial_h_ 00161 00162 // include basic definitions 00163 #include "pbori_defs.h" 00164 00165 // get definition of BoolePolynomial and BooleVariable 00166 #include "BoolePolynomial.h" 00167 #include "BooleVariable.h" 00168 // get standard map functionality 00169 #include <map> 00170 00171 // get variable iterator 00172 #include "CVariableIter.h" 00173 00174 // get variable iterator 00175 #include "PBoRiError.h" 00176 00177 BEGIN_NAMESPACE_PBORI 00178 00179 class BooleVariable; 00180 class BooleExponent; 00181 template <class DDType, class MonomType> class CDDOperations; 00182 00191 class BooleMonomial { 00192 00193 public: 00194 template <class, class> friend class CDDOperations; 00195 friend class COrderBase; 00196 template <class, class> friend class CTermGeneratorBase; 00197 00198 //------------------------------------------------------------------------- 00199 // types definitions 00200 //------------------------------------------------------------------------- 00201 00203 00204 typedef CTypes::dd_type dd_type; 00205 typedef CTypes::size_type size_type; 00206 typedef CTypes::deg_type deg_type; 00207 typedef CTypes::idx_type idx_type; 00208 typedef CTypes::hash_type hash_type; 00209 typedef CTypes::bool_type bool_type; 00210 typedef CTypes::comp_type comp_type; 00211 typedef CTypes::integer_type integer_type; 00212 typedef CTypes::ostream_type ostream_type; 00214 00216 typedef BooleMonomial self; 00217 00219 typedef BoolePolynomial poly_type; 00220 00222 typedef poly_type::var_type var_type; 00223 00225 typedef poly_type::constant_type constant_type; 00226 00228 typedef poly_type::set_type set_type; 00229 00231 typedef poly_type::exp_type exp_type; 00232 00234 typedef poly_type::ring_type ring_type; 00235 00237 typedef poly_type::first_iterator const_iterator; 00238 00240 typedef CVariableIter<const_iterator, var_type> variable_iterator; 00241 00243 // typedef generate_index_map<self>::type idx_map_type; 00244 00245 typedef std::map<self, idx_type, symmetric_composition< 00246 std::less<poly_type::navigator>, 00247 navigates<poly_type> > > idx_map_type; 00248 00250 typedef dd_type::easy_equality_property easy_equality_property; 00251 00253 BooleMonomial(): 00254 m_poly( BooleEnv::one() ) { } 00255 00257 BooleMonomial(const self& rhs): 00258 m_poly(rhs.m_poly) {} 00259 00261 BooleMonomial(const var_type& rhs); // not inlined to avoid dependency loop 00262 // (both depend on poly_type) 00263 00265 BooleMonomial(const exp_type& rhs, const ring_type& ring): 00266 m_poly(rhs, ring) { } 00267 00269 BooleMonomial(const ring_type& ring): 00270 m_poly(ring.one()) {} 00271 00273 ~BooleMonomial() {} 00274 00276 operator const BoolePolynomial&() const { return m_poly; } 00277 00279 exp_type exp() const; 00280 00281 00283 const_iterator begin() const { return m_poly.firstBegin(); } 00284 00286 const_iterator end() const { return m_poly.firstEnd(); } 00287 00289 variable_iterator variableBegin() const { 00290 return variable_iterator(begin(), ring()); 00291 } 00292 00294 variable_iterator variableEnd() const { 00295 return variable_iterator(end(), ring()); 00296 } 00297 00299 deg_type deg() const { 00301 #if 0 00302 return m_poly.nNodes(); 00303 #else 00304 return std::distance(m_poly.firstBegin(),m_poly.firstEnd()); 00305 #endif 00306 } 00307 00309 size_type size() const { return (size_type)deg(); } // always nonnegative 00310 00312 set_type divisors() const { return m_poly.lmDivisors(); } 00313 00315 set_type multiples(const self&) const; 00316 00318 hash_type stableHash() const { 00319 return stable_first_hash_range(m_poly.navigation()); 00320 } 00321 00323 hash_type hash() const { return m_poly.hash(); } 00324 00326 self& changeAssign(idx_type); 00327 00329 self change(idx_type) const; 00330 00331 00333 00334 self& operator*=(const self&); 00335 self& operator/=(const self&); 00336 self& operator*=(const var_type&); 00337 self& operator/=(const var_type&); 00339 00341 00342 bool_type operator==(const self& rhs) const { return m_poly == rhs.m_poly; } 00343 bool_type operator!=(const self& rhs) const { return m_poly != rhs.m_poly; } 00344 bool_type operator==(constant_type rhs) const { return m_poly == rhs; } 00345 bool_type operator!=(constant_type rhs) const { return m_poly != rhs; } 00346 bool_type isOne() const { return m_poly.isOne(); } 00347 bool_type isConstant() const { return m_poly.isConstant(); } 00349 00351 bool_type reducibleBy(const self& rhs) const { 00352 return m_poly.reducibleBy(rhs); } 00353 bool_type reducibleBy(const var_type& rhs) const; 00354 00356 comp_type compare(const self&) const; 00357 00359 deg_type LCMDeg(const self&) const; 00360 00362 self& LCMAssign(const self&); 00363 00365 self LCM(const self&) const; 00366 00368 self& GCDAssign(const self&); 00369 00371 self GCD(const self&) const; 00372 00374 const dd_type& diagram() const { return m_poly.diagram(); } 00375 00377 set_type set() const { return m_poly.set(); } 00378 00380 self& popFirst() { 00381 assert(!m_poly.isConstant()); 00382 return *this = set_type( dd_type(m_poly.diagram().manager(), 00383 m_poly.navigation().thenBranch()) ); 00384 } 00385 00387 var_type firstVariable() const; 00388 00390 idx_type firstIndex() const { 00391 assert(!m_poly.isConstant()); 00392 return *begin(); 00393 } 00394 00396 ring_type ring() const { return m_poly.ring(); } 00397 00398 protected: 00400 dd_type& internalDiagram() { return m_poly.internalDiagram(); } 00401 00403 // BooleMonomial(const dd_type& rhs): m_poly(rhs) {} 00405 BooleMonomial(const set_type& rhs): m_poly(rhs.diagram()) { 00406 assert(!m_poly.isZero()); 00407 } 00408 00409 private: 00410 BoolePolynomial m_poly; 00411 }; 00412 00414 inline BooleMonomial 00415 operator*(const BooleMonomial& lhs, const BooleMonomial& rhs) { 00416 return BooleMonomial(lhs) *= rhs; 00417 } 00419 inline BooleMonomial 00420 operator*(const BooleMonomial& lhs, const BooleVariable& rhs) { 00421 return BooleMonomial(lhs) *= rhs; 00422 } 00424 inline BoolePolynomial 00425 operator*(const BooleMonomial& lhs, BooleConstant rhs) { 00426 return BoolePolynomial(lhs) *= rhs; 00427 } 00428 00430 inline BoolePolynomial 00431 operator*(BooleConstant lhs, const BooleMonomial& rhs) { 00432 return rhs * lhs; 00433 } 00434 00436 inline BooleMonomial 00437 operator/(const BooleMonomial& lhs, const BooleMonomial& rhs) { 00438 return BooleMonomial(lhs) /= rhs; 00439 } 00440 00442 inline BooleMonomial 00443 operator/(const BooleMonomial& lhs, const BooleVariable& rhs) { 00444 return lhs / BooleMonomial(rhs); 00445 } 00446 00448 inline BooleMonomial::bool_type 00449 operator<(const BooleMonomial& lhs, const BooleMonomial& rhs) { 00450 00451 return (lhs.compare(rhs) == CTypes::less_than); 00452 } 00453 00455 inline BooleMonomial::bool_type 00456 operator>(const BooleMonomial& lhs, const BooleMonomial& rhs) { 00457 00458 return (lhs.compare(rhs) == CTypes::greater_than); 00459 } 00460 00462 inline BooleMonomial::bool_type 00463 operator<=(const BooleMonomial& lhs, const BooleMonomial& rhs) { 00464 00465 return (lhs.compare(rhs) <= CTypes::less_or_equal_max); 00466 } 00467 00469 inline BooleMonomial::bool_type 00470 operator>=(const BooleMonomial& lhs, const BooleMonomial& rhs) { 00471 00472 return (lhs.compare(rhs) >= CTypes::greater_or_equal_min); 00473 } 00474 00475 00477 inline BooleMonomial 00478 GCD(const BooleMonomial& lhs, const BooleMonomial& rhs ){ 00479 00480 return lhs.GCD(rhs); 00481 } 00482 00484 inline BooleMonomial 00485 LCM(const BooleMonomial& lhs, const BooleMonomial& rhs ){ 00486 00487 return lhs.LCM(rhs); 00488 } 00489 00492 BooleMonomial::bool_type 00493 greater_variable(BooleMonomial::idx_type lhs, BooleMonomial::idx_type rhs); 00494 00495 00497 inline BoolePolynomial 00498 operator*(const BooleVariable& lhs, const BooleConstant& rhs){ 00499 00500 return BooleMonomial(lhs) * rhs; 00501 } 00502 00504 inline BoolePolynomial 00505 operator*(const BooleConstant& lhs, const BooleVariable& rhs){ 00506 00507 return rhs * lhs; 00508 } 00509 00511 inline BoolePolynomial 00512 operator*(const BooleVariable& lhs, 00513 const BoolePolynomial& rhs){ 00514 00515 return BoolePolynomial(rhs) *= BooleMonomial(lhs); 00516 } 00517 00519 inline BooleMonomial 00520 operator*(const BooleVariable& lhs, 00521 const BooleMonomial& rhs){ 00522 00523 return BooleMonomial(lhs) * rhs; 00524 } 00525 00527 inline BoolePolynomial& 00528 operator*=(BoolePolynomial& lhs, 00529 const BooleVariable& rhs){ 00530 00531 return lhs *= BooleMonomial(rhs); 00532 } 00533 00535 inline BooleMonomial 00536 operator*(const BooleVariable& lhs, 00537 const BooleVariable& rhs){ 00538 00539 return BooleMonomial(lhs) *= BooleMonomial(rhs); 00540 } 00541 00543 inline BoolePolynomial 00544 operator*(const BoolePolynomial& lhs, 00545 const BooleVariable& rhs){ 00546 00547 return BoolePolynomial(lhs) *= BooleMonomial(rhs); 00548 } 00549 00551 inline BoolePolynomial& 00552 operator/=(BoolePolynomial& lhs, const BooleVariable& rhs){ 00553 00554 return lhs /= BooleMonomial(rhs); 00555 } 00556 00558 inline BoolePolynomial 00559 operator/(const BoolePolynomial& lhs, 00560 const BooleVariable& rhs){ 00561 00562 return lhs / BooleMonomial(rhs); 00563 } 00564 00565 00567 inline BoolePolynomial 00568 operator%(const BoolePolynomial& lhs, 00569 const BooleVariable& rhs){ 00570 00571 return lhs % BooleMonomial(rhs); 00572 } 00573 00575 inline BoolePolynomial& 00576 operator%=(BoolePolynomial& lhs, 00577 const BooleVariable& rhs){ 00578 00579 return lhs %= BooleMonomial(rhs); 00580 } 00581 00582 END_NAMESPACE_PBORI 00583 00584 00585 #endif // of BooleMonomial_h_