PolyBoRi
|
00001 // -*- c++ -*- 00002 //***************************************************************************** 00100 //***************************************************************************** 00101 00102 00103 // include basic definitions 00104 #include "pbori_defs.h" 00105 #include "pbori_algo.h" 00106 00107 00108 #include "BoolePolynomial.h" 00109 #include "OrderedManager.h" 00110 #include "CDelayedTermIter.h" 00111 #include "CBidirectTermIter.h" 00112 #include <algorithm> 00113 00114 #include "CStackSelector.h" 00115 #include "CTermGenerator.h" 00116 00117 #ifndef COrderedIter_h_ 00118 #define COrderedIter_h_ 00119 00120 BEGIN_NAMESPACE_PBORI 00121 00122 00123 template <class NavigatorType> 00124 class CAbstractStackBase { 00125 public: 00126 typedef NavigatorType navigator; 00127 00128 typedef CAbstractStackBase<NavigatorType> self; 00129 typedef CTermStackBase<NavigatorType, self> iterator_core; 00130 typedef PBORI_SHARED_PTR(iterator_core) core_pointer; 00131 00132 virtual void increment() = 0; 00133 virtual core_pointer copy() const = 0; 00134 00135 virtual ~CAbstractStackBase() {} 00136 }; 00137 00138 00139 00140 template <class StackType> 00141 class CWrappedStack: 00142 public StackType { 00143 public: 00144 typedef StackType base; 00145 typedef CWrappedStack<StackType> self; 00146 00147 typedef typename base::navigator navigator; 00148 00149 typedef typename base::iterator_core iterator_core; 00150 typedef PBORI_SHARED_PTR(iterator_core) core_pointer; 00151 00152 template <class MgrType> 00153 CWrappedStack(navigator navi, const MgrType& mgr): 00154 base(navi, mgr) { 00155 base::init(); 00156 } 00157 CWrappedStack(): base() {} 00158 CWrappedStack(const self& rhs): base(rhs) {} 00159 00160 00161 core_pointer copy() const { 00162 return core_pointer(new self(*this)); 00163 } 00164 00165 }; 00166 00167 00168 // template<class SequenceType> 00169 // void get_term(BooleMonomial& monom, const SequenceType& seq) { 00170 00171 // typename SequenceType::const_reverse_iterator start(seq.rbegin()), 00172 // finish(seq.rend()); 00173 00174 // while (start != finish){ 00175 // monom.changeAssign(*start); 00176 // ++start; 00177 // } 00178 // } 00179 00180 00181 // template<class SequenceType> 00182 // void get_term(BooleExponent& termexp, const SequenceType& seq) { 00183 00184 // termexp.reserve(seq.deg()); 00185 // typename SequenceType::const_iterator start(seq.begin()), 00186 // finish(seq.end()); 00187 00188 // while (start != finish){ 00189 // termexp.push_back(*start); 00190 // ++start; 00191 // } 00192 // } 00193 00194 00195 // template<class SequenceType> 00196 // void get_term(typename CTypes::size_type& termdeg, const SequenceType& seq) { 00197 00198 // termdeg = seq.deg(); 00199 // } 00200 00201 template <class NavigatorType, class MonomType> 00202 class COrderedIter: 00203 public boost::iterator_facade< 00204 COrderedIter<NavigatorType, MonomType>, 00205 MonomType, std::forward_iterator_tag, MonomType 00206 > { 00207 00208 public: 00209 00210 typedef COrderedIter<NavigatorType, MonomType> self; 00211 typedef CAbstractStackBase<NavigatorType> stack_base; 00212 typedef CTermStackBase<NavigatorType, stack_base> iterator_core; 00213 00215 typedef CTermGenerator<MonomType> term_generator; 00216 00217 typedef typename iterator_core::const_iterator const_iterator; 00218 typedef typename iterator_core::const_reverse_iterator 00219 const_reverse_iterator; 00220 typedef typename iterator_core::size_type size_type; 00221 typedef typename iterator_core::deg_type deg_type; 00222 typedef typename iterator_core::idx_type idx_type; 00223 00224 00226 typedef NavigatorType navigator; 00227 00228 // Store shared pointer of iterator 00229 typedef PBORI_SHARED_PTR(iterator_core) core_pointer; 00230 00232 typedef bool bool_type; 00233 00234 // Constructor 00235 COrderedIter(core_pointer rhs, 00236 const term_generator & getTerm): 00237 m_getTerm(getTerm), p_iter(rhs) {} 00238 00239 // Destructor 00240 ~COrderedIter() {} 00241 00242 bool equal(const self& rhs) const { 00243 return p_iter->equal(*rhs.p_iter); } 00244 00246 void increment() { 00247 if (!p_iter.unique()) { 00248 core_pointer tmp(p_iter->copy()); 00249 p_iter = tmp; 00250 } 00251 00252 p_iter->increment(); 00253 } 00254 00256 bool_type isOne() const { return p_iter->isOne(); } 00257 00259 bool_type isZero() const { return p_iter->isZero(); } 00260 00262 bool_type isEnd() const { return isZero(); } 00263 00265 MonomType dereference() const { 00266 00267 return m_getTerm(*p_iter); 00268 } 00269 00270 const_iterator begin() const { return p_iter->begin(); } 00271 const_iterator end() const { return p_iter->end(); } 00272 const_reverse_iterator rbegin() const { return p_iter->rbegin(); } 00273 const_reverse_iterator rend() const { return p_iter->rend(); } 00274 00275 deg_type deg() const { return p_iter->deg(); } 00276 idx_type firstIndex() const { return *begin(); } 00277 00279 navigator navigation() const { 00280 return p_iter->navigation(); 00281 } 00282 00283 protected: 00285 term_generator m_getTerm; 00286 00288 core_pointer p_iter; 00289 }; 00290 00291 00292 template <class OrderType, class NavigatorType, class MonomType> 00293 class CGenericOrderedIter: 00294 public COrderedIter<NavigatorType, MonomType> { 00295 public: 00296 typedef CAbstractStackBase<NavigatorType> stack_base; 00297 typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type 00298 ordered_iter_base; 00299 typedef CWrappedStack<ordered_iter_base> ordered_iter_type; 00300 00301 typedef COrderedIter<NavigatorType, MonomType> base; 00302 typedef typename base::iterator_core iterator_core; 00303 typedef typename base::core_pointer core_pointer; 00304 00305 typedef typename base::term_generator term_generator; 00306 00307 template <class MgrType> 00308 CGenericOrderedIter(NavigatorType navi, const MgrType& gen): 00309 base( core_pointer(new ordered_iter_type(navi, gen) ), gen) {} 00310 CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()), 00311 term_generator() ) {} 00312 00313 CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {} 00314 }; 00315 00316 template <class OrderType, class NavigatorType> 00317 class CGenericOrderedIter<OrderType, NavigatorType, BooleExponent> : 00318 public COrderedIter<NavigatorType, BooleExponent> { 00319 public: 00320 typedef CAbstractStackBase<NavigatorType> stack_base; 00321 typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type 00322 ordered_iter_base; 00323 typedef CWrappedStack<ordered_iter_base> ordered_iter_type; 00324 00325 typedef COrderedIter<NavigatorType, BooleExponent> base; 00326 typedef typename base::iterator_core iterator_core; 00327 typedef typename base::core_pointer core_pointer; 00328 00329 typedef typename base::term_generator term_generator; 00330 00331 template <class MgrType> 00332 CGenericOrderedIter(NavigatorType navi, const MgrType& mgr): 00333 base( core_pointer(new ordered_iter_type(navi, mgr)), 00334 term_generator() ) {} 00335 00336 CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()), 00337 term_generator() ) {} 00338 00339 CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {} 00340 }; 00341 00342 END_NAMESPACE_PBORI 00343 00344 #endif