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