PolyBoRi
|
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