PolyBoRi
CTermGenerator.h
Go to the documentation of this file.
00001 // -*- c++ -*-
00002 //*****************************************************************************
00015 //*****************************************************************************
00016 
00017 #ifndef polybori_iterators_CTermGenerator_h_
00018 #define polybori_iterators_CTermGenerator_h_
00019 
00020 // include basic definitions
00021 #include <polybori/pbori_defs.h>
00022 
00023 // include polybori functionals
00024 #include <polybori/routines/pbori_func.h>
00025 
00026   //#include <polybori/BooleSet.h>
00027 
00028 
00029 
00030 BEGIN_NAMESPACE_PBORI
00031 
00032 
00033 template <class TermType, class BehaviourTag>
00034 class CTermGeneratorBase__;
00035 
00036 
00037 class BooleExponent;
00038 template <class TermType>
00039 class CTermGeneratorBase__<TermType, type_tag<BooleExponent> > {
00040 
00041 public:
00042   typedef TermType value_type;
00043   typedef value_type result_type;
00044 
00045   template <class SequenceType>
00046   result_type operator()(const SequenceType& seq) const{
00047 
00048     value_type result;
00049     result.reserve(seq.deg());
00050     typename SequenceType::const_iterator 
00051       start(seq.begin()), finish(seq.end());
00052 
00053     while (start != finish){
00054       result.push_back(*start);
00055       ++start;
00056     }
00057     return result;
00058   }
00059 };
00060 
00061 template <class TermType>
00062 class CTermGeneratorBase__<TermType, type_tag<CTypes::size_type> > {
00063 public:
00064   typedef TermType value_type;
00065   typedef value_type result_type;
00066 
00067   template <class SequenceType>
00068   result_type operator()(const SequenceType& seq) const{
00069     return seq.deg();
00070   }
00071 };
00072 
00073 
00074 template <class TermType>
00075 class CTermGeneratorBase__<TermType, type_tag<CTypes::deg_type> > {
00076 public:
00077   typedef TermType value_type;
00078   typedef value_type result_type;
00079 
00080   template <class SequenceType>
00081   result_type operator()(const SequenceType& seq) const{
00082     return seq.deg();
00083   }
00084 };
00085 
00086 
00088 
00089 
00090 template <class TermType>
00091 class CTermGeneratorBase__<TermType, type_tag<BooleMonomial> >{
00092 
00093 public:
00094   typedef TermType value_type;
00095   typedef value_type result_type;
00096 
00097   //  typedef  CTypes::manager_base manager_base;
00098 
00099 
00100   typedef  BoolePolyRing data_type;
00101   typedef  data_type::dd_type dd_type;
00102 
00103   // typedef  CTypes::manager_base data_type;
00104   data_type m_data;
00106 
00107   CTermGeneratorBase__(const data_type& data): m_data(data) {}
00108 
00109   CTermGeneratorBase__(): m_data() {}
00110 
00111   template <class SequenceType>
00112   result_type operator()(const SequenceType& seq) const {
00114 
00115     // Do not dereference empty sequence (corresponds to end())
00116     PBORI_ASSERT(!seq.isZero());
00117 
00118     // @todo: avoid using manager_base here
00119     typedef typename value_type::ring_type ring_type;
00121     //    value_type result((ring_type)manager_type(m_data));
00122     value_type result((ring_type)(m_data));
00123 
00124     typename SequenceType::stack_reverse_iterator 
00125       start(seq.stackRBegin()), finish(seq.stackREnd());
00126 
00127 #ifndef PBORI_NO_TERMS_BY_TAIL
00128     typename BooleSet::navigator navi(result.diagram().navigation());
00129 
00130     PBORI_ASSERT((start == finish) || !start->isConstant());
00131     while((start != finish) && 
00132           (start->elseBranch().isEmpty()) && (start->thenBranch() == navi)  ) {
00133       navi = *start;
00134       ++start;
00135     }
00136 
00137     result = value_type(dd_type(m_data, navi));
00138 #endif
00139 
00140     while (start != finish){
00141       result = result.change(**start);
00142       ++start;
00143     }
00144     
00145     return result;
00146   }
00147 };
00148 
00149 
00150 template <class TermType>
00151 class CTermGeneratorBase:
00152   public CTermGeneratorBase__<TermType, type_tag<TermType> > {
00153 
00154 };
00155 
00156 
00157 template <class TermType>
00158 class CTermGenerator:
00159   public CTermGeneratorBase<TermType> {
00160 public:
00161   typedef CTermGeneratorBase<TermType> base;
00162 
00163   typedef BoolePolyRing data_type;
00164 
00165   CTermGenerator(const data_type&): base() {}
00166   CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00167   CTermGenerator(): base() {}
00168 
00169 };
00170 
00171 
00172 template <>
00173 class CTermGenerator<BooleMonomial>:
00174   public CTermGeneratorBase__<BooleMonomial, type_tag<BooleMonomial> > {
00175 public:
00176   typedef BooleMonomial term_type;
00177   typedef CTermGeneratorBase__<BooleMonomial, type_tag<BooleMonomial> > base;
00178   //typedef CTermGeneratorBase<term_type> base;
00179   typedef base::data_type data_type;
00180 
00181   CTermGenerator(const data_type& data): base(data) {}
00182   CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00183   //  CTermGenerator(): base() {}
00184 };
00185 
00186 END_NAMESPACE_PBORI
00187 
00188 #endif