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