• Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

BooleExponent.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 //*****************************************************************************
00070 //*****************************************************************************
00071 
00072 #ifndef BooleExponent_h_
00073 #define BooleExponent_h_
00074 
00075 // include basic definitions
00076 #include "pbori_defs.h"
00077 
00078 // get definition of BoolePolynomial, BooleMonomial, and BooleVariable
00079 #include "BooleMonomial.h"
00080 #include "BooleVariable.h"
00081 
00082 BEGIN_NAMESPACE_PBORI
00083 
00089 class BooleExponent {
00090 
00091  public:
00092 
00093   //-------------------------------------------------------------------------
00094   // types definitions
00095   //-------------------------------------------------------------------------
00096 
00098 
00099   typedef CTypes::dd_type dd_type;
00100   typedef CTypes::size_type size_type;
00101   typedef CTypes::idx_type idx_type;
00102   typedef CTypes::hash_type hash_type;
00103   typedef CTypes::bool_type bool_type;
00104   typedef CTypes::comp_type comp_type;
00105   typedef CTypes::integer_type integer_type;
00106   typedef CTypes::ostream_type ostream_type;
00108 
00110   typedef std::vector<idx_type> data_type;
00111 
00113   typedef data_type::value_type value_type;
00114 
00116 
00117   typedef data_type::iterator iterator;
00118   typedef data_type::const_iterator const_iterator;
00119   typedef data_type::reverse_iterator reverse_iterator;
00120   typedef data_type::const_reverse_iterator const_reverse_iterator;
00122 
00124   typedef BooleExponent self;
00125 
00127   typedef BoolePolynomial poly_type;
00128 
00130   typedef BooleVariable var_type;
00131 
00133   typedef BooleMonomial monom_type;
00134 
00136   typedef BooleSet set_type;
00137 
00139   typedef generate_index_map<self>::type idx_map_type;
00140 
00142   typedef invalid_tag easy_equality_property;
00143 
00145   BooleExponent();
00146 
00148   BooleExponent(const self&);
00149 
00150   explicit BooleExponent(bool);
00151 
00153   self& get(const monom_type&);
00154 
00155 //   /// Construct from Boolean constant
00156 //   BooleExponent(bool_type);
00157 
00159   ~BooleExponent();
00160 
00162   const_iterator begin() const { return m_data.begin(); }
00163 
00165   const_iterator end() const { return m_data.end(); }
00166 
00168   const_reverse_iterator rbegin() const { return m_data.rbegin(); }
00169 
00171   const_reverse_iterator rend() const { return m_data.rend(); }
00172 
00174   size_type size() const { return m_data.size(); }
00175 
00177   void reserve(size_type nsize) { m_data.reserve(nsize); }
00178 
00180   void resize(size_type nsize) { m_data.resize(nsize); }
00181 
00183   size_type deg() const { return size(); }
00184 
00186   set_type divisors() const;
00187 
00189   set_type multiples(const self&) const; 
00190 
00192   hash_type stableHash() const {
00193     return stable_term_hash(begin(), end());
00194   }
00195 
00197   hash_type hash() const { return stableHash(); }
00198 
00200   self& changeAssign(idx_type);
00201 
00203   self change(idx_type) const;
00204 
00206   self& insert(idx_type);
00207 
00209   self& push_back(idx_type idx);
00210 
00212   self& remove(idx_type);
00213 
00215   self insertConst(idx_type) const;
00216 
00218   self removeConst(idx_type) const;
00219 
00221   self divide(const self&) const;
00222   self divide(const idx_type& rhs) const { 
00223     return (reducibleBy(rhs)? removeConst(rhs) : self() ); }
00224 
00225   self divide(const var_type& rhs) const { return divide(rhs.index()); }
00226   self divide(const monom_type&) const;
00227 
00229   self multiply(const self&) const;
00230 
00231   self multiply(const idx_type& rhs) const { return insertConst(rhs); }
00232   self multiply(const var_type& rhs) const { return multiply(rhs.index()); }
00233   self multiply(const monom_type&) const;
00234   self multiplyFirst(const set_type&) const;
00235 
00236 
00237 //   /// @name Arithmetical operations
00238 //   //@{
00239 //   self& operator*=(const self&);
00240 //   self& operator/=(const self&);
00241 //   self& operator*=(const var_type&);
00242 //   self& operator/=(const var_type&);
00243 //   //@}
00244 
00246 
00247   bool_type operator==(const self& rhs) const { return m_data == rhs.m_data; }
00248   bool_type operator!=(const self& rhs) const { return m_data != rhs.m_data; }
00250 
00252   self& operator=(const self& rhs) { m_data = rhs.m_data; return *this; }
00253   self& operator=(const monom_type& rhs) {
00254     m_data.resize(rhs.size());
00255     std::copy(rhs.begin(), rhs.end(), internalBegin());
00256     return *this;
00257   }
00258 
00260   bool_type reducibleBy(const self& rhs) const;
00261   bool_type reducibleBy(const monom_type& rhs) const;
00262   bool_type reducibleBy(const idx_type& rhs) const;
00263   bool_type reducibleBy(const var_type& rhs) const { 
00264     return reducibleBy(rhs.index()); }
00265 
00266 
00267 //   /// Test for reducibility wrt. to a given variable
00268 //   bool_type reducibleBy(const var_type& rhs) const;
00269 
00271   comp_type compare(const self&) const;
00272 
00274   size_type LCMDeg(const self&) const;
00275 
00278 
00280   self LCM(const self&) const;
00281 
00283   //self& GCDAssign(const self&);
00284 
00286   self GCD(const self&) const;
00287 
00289   self& popFirst() { 
00290     assert(!m_data.empty());
00291     m_data.erase(m_data.begin());
00292     return *this; 
00293   }
00294 
00296   ostream_type& print(ostream_type&) const;
00297  
00298 protected:
00300   iterator internalBegin() { return m_data.begin(); }
00301 
00303   iterator internalEnd() { return m_data.end(); }
00304 
00306   reverse_iterator rInternalBegin() { return m_data.rbegin(); }
00307 
00309   reverse_iterator rInternalEnd() { return m_data.rend(); }
00310 
00312   data_type m_data;
00313 };
00314 
00315 
00317 template <class RHSType>
00318 inline BooleExponent
00319 operator+(const BooleExponent& lhs, const RHSType& rhs) {
00320   return lhs.multiply(rhs);
00321 }
00322 
00324 template <class RHSType>
00325 inline BooleExponent
00326 operator-(const BooleExponent& lhs, const RHSType& rhs) {
00327   return lhs.divide(rhs);
00328 }
00329 
00330 
00332 inline BooleExponent::bool_type
00333 operator<(const BooleExponent& lhs, const BooleExponent& rhs) {
00334 
00335   return (lhs.compare(rhs) == CTypes::less_than);
00336 }
00337 
00339 inline BooleExponent::bool_type
00340 operator>(const BooleExponent& lhs, const BooleExponent& rhs) {
00341 
00342   return (lhs.compare(rhs) == CTypes::greater_than);
00343 }
00344 
00346 inline BooleExponent::bool_type
00347 operator<=(const BooleExponent& lhs, const BooleExponent& rhs) {
00348 
00349   return (lhs.compare(rhs) <= CTypes::less_or_equal_max);
00350 }
00351 
00353 inline BooleExponent::bool_type
00354 operator>=(const BooleExponent& lhs, const BooleExponent& rhs) {
00355 
00356   return (lhs.compare(rhs) >= CTypes::greater_or_equal_min);
00357 }
00358 
00359 
00361 inline BooleExponent
00362 GCD(const BooleExponent& lhs, const BooleExponent& rhs ){
00363 
00364   return lhs.GCD(rhs);
00365 }
00366 
00368 inline BooleExponent
00369 LCM(const BooleExponent& lhs, const BooleExponent& rhs ){
00370 
00371   return lhs.LCM(rhs);
00372 }
00373 
00374 
00376 inline BooleExponent::ostream_type& 
00377 operator<<(BooleExponent::ostream_type& os, const BooleExponent& rhs) {
00378   return rhs.print(os);
00379 }
00380 
00381 END_NAMESPACE_PBORI
00382 
00383 #endif // of BooleExponent_h_

Generated on Thu Oct 21 2010 02:56:31 for PolyBoRi by  doxygen 1.7.1