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

CTermGenerator.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 //*****************************************************************************
00067 //*****************************************************************************
00068 
00069 // include basic definitions
00070 #include "pbori_defs.h"
00071 
00072 // include polybori functionals
00073 #include "pbori_func.h"
00074 
00075 #include "BooleSet.h"
00076 
00077 #ifndef CTermGenerator_h_
00078 #define CTermGenerator_h_
00079 
00080 BEGIN_NAMESPACE_PBORI
00081 
00082 
00083 template <class TermType, class BehaviourTag = type_tag<TermType> >
00084 class CTermGeneratorBase;
00085 
00086 #if 0
00087 template <class TermType>
00088 class CTermGeneratorBase<TermType, type_tag<BooleMonomial> >{
00089 
00090 public:
00091   typedef TermType value_type;
00092   typedef value_type result_type;
00093 
00094   template <class SequenceType>
00095   result_type operator()(const SequenceType& seq) const{
00096 
00097     value_type result(!seq.isZero());
00098 
00099     typename SequenceType::stack_reverse_iterator 
00100       start(seq.stackRBegin()), finish(seq.stackREnd());
00101 
00102 #ifndef PBORI_NO_TERMS_BY_TAIL
00103     typename BooleSet::navigator navi(result.diagram().navigation());
00104 
00105     assert((start == finish) || !start->isConstant());
00106     while((start != finish) && 
00107           (start->elseBranch().isEmpty()) && (start->thenBranch() == navi)  ) {
00108       navi = *start;
00109       ++start;
00110     }
00111 
00112     result = value_type(BooleSet(navi));
00113 #endif
00114 
00115     while (start != finish){
00116       result.changeAssign(**start);
00117       ++start;
00118     }
00119     
00120     return result;
00121   }
00122 };
00123 #endif //if0
00124 
00125 class BooleExponent;
00126 template <class TermType>
00127 class CTermGeneratorBase<TermType, type_tag<BooleExponent> > {
00128 
00129 public:
00130   typedef TermType value_type;
00131   typedef value_type result_type;
00132 
00133   template <class SequenceType>
00134   result_type operator()(const SequenceType& seq) const{
00135 
00136     value_type result;
00137     result.reserve(seq.deg());
00138     typename SequenceType::const_iterator 
00139       start(seq.begin()), finish(seq.end());
00140 
00141     while (start != finish){
00142       result.push_back(*start);
00143       ++start;
00144     }
00145     return result;
00146   }
00147 };
00148 
00149 template <class TermType>
00150 class CTermGeneratorBase<TermType, type_tag<CTypes::size_type> > {
00151 public:
00152   typedef TermType value_type;
00153   typedef value_type result_type;
00154 
00155   template <class SequenceType>
00156   result_type operator()(const SequenceType& seq) const{
00157     return seq.deg();
00158   }
00159 };
00160 
00161 
00162 
00163 template <class TermType>
00164 class CTermGenerator:
00165   public CTermGeneratorBase<TermType> {
00166 public:
00167   typedef CTermGeneratorBase<TermType> base;
00168 
00169   typedef  CTypes::dd_type dd_type;
00170   typedef  dd_type::core_type data_type;
00171 
00172   CTermGenerator(const data_type&): base() {}
00173   CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00174   CTermGenerator(): base() {}
00175 
00176 };
00177 
00179 class NoData {};
00180 
00181 
00182 template <class TermType, class BehaviourTag = type_tag<TermType> >
00183 class MyCTermGeneratorBase;
00184 
00185 template <class TermType>
00186 class CTermGeneratorBase<TermType, type_tag<BooleMonomial> >{
00187 
00188 public:
00189   typedef TermType value_type;
00190   typedef value_type result_type;
00191 
00192   typedef  CTypes::manager_base manager_base;
00193 
00194   typedef  CTypes::dd_type dd_type;
00195   typedef  dd_type::core_type data_type;
00196 
00197   // typedef  CTypes::manager_base data_type;
00198   data_type m_data;
00200 
00201   CTermGeneratorBase(const data_type& data): m_data(data) {}
00202 
00203   CTermGeneratorBase(): m_data() {}
00204 
00205   template <class SequenceType>
00206   result_type operator()(const SequenceType& seq) const {
00207     assert(m_data != data_type());
00208 
00209     // Do not dereference empty sequence (corresponds to end())
00210     assert(!seq.isZero());
00211 
00212     // @todo: avoid using manager_base here
00213     typedef typename value_type::ring_type ring_type;
00214     typedef typename ring_type::manager_type manager_type;
00215     value_type result((ring_type)manager_type(m_data));
00216 
00217     typename SequenceType::stack_reverse_iterator 
00218       start(seq.stackRBegin()), finish(seq.stackREnd());
00219 
00220 #ifndef PBORI_NO_TERMS_BY_TAIL
00221     typename BooleSet::navigator navi(result.diagram().navigation());
00222 
00223     assert((start == finish) || !start->isConstant());
00224     while((start != finish) && 
00225           (start->elseBranch().isEmpty()) && (start->thenBranch() == navi)  ) {
00226       navi = *start;
00227       ++start;
00228     }
00229 
00230     result = value_type(dd_type(m_data, navi));
00231 #endif
00232 
00233     while (start != finish){
00234       result.changeAssign(**start);
00235       ++start;
00236     }
00237     
00238     return result;
00239   }
00240 };
00241 
00242 
00243 template <>
00244 class CTermGenerator<BooleMonomial>:
00245   public CTermGeneratorBase<BooleMonomial> {
00246 public:
00247   typedef BooleMonomial term_type;
00248   typedef CTermGeneratorBase<term_type> base;
00249   typedef base::data_type data_type;
00250 
00251   CTermGenerator(const data_type& data): base(data) {}
00252   CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00253   CTermGenerator(): base() {}
00254 };
00255 
00256 END_NAMESPACE_PBORI
00257 
00258 #endif

Generated on Thu Oct 21 2010 06:56:30 for PolyBoRi by  doxygen 1.7.1