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