Go to the documentation of this file.00001
00002
00067
00068
00069
00070 #include "pbori_defs.h"
00071
00072
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
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
00210 assert(!seq.isZero());
00211
00212
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