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 template <class TermType>
00163 class CTermGeneratorBase<TermType, type_tag<CTypes::deg_type> > {
00164 public:
00165 typedef TermType value_type;
00166 typedef value_type result_type;
00167
00168 template <class SequenceType>
00169 result_type operator()(const SequenceType& seq) const{
00170 return seq.deg();
00171 }
00172 };
00173
00174 template <class TermType>
00175 class CTermGenerator:
00176 public CTermGeneratorBase<TermType> {
00177 public:
00178 typedef CTermGeneratorBase<TermType> base;
00179
00180 typedef CTypes::dd_type dd_type;
00181 typedef dd_type::core_type data_type;
00182
00183 CTermGenerator(const data_type&): base() {}
00184 CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00185 CTermGenerator(): base() {}
00186
00187 };
00188
00190 class NoData {};
00191
00192
00193 template <class TermType, class BehaviourTag = type_tag<TermType> >
00194 class MyCTermGeneratorBase;
00195
00196 template <class TermType>
00197 class CTermGeneratorBase<TermType, type_tag<BooleMonomial> >{
00198
00199 public:
00200 typedef TermType value_type;
00201 typedef value_type result_type;
00202
00203 typedef CTypes::manager_base manager_base;
00204
00205 typedef CTypes::dd_type dd_type;
00206 typedef dd_type::core_type data_type;
00207
00208
00209 data_type m_data;
00211
00212 CTermGeneratorBase(const data_type& data): m_data(data) {}
00213
00214 CTermGeneratorBase(): m_data() {}
00215
00216 template <class SequenceType>
00217 result_type operator()(const SequenceType& seq) const {
00218 assert(m_data != data_type());
00219
00220
00221 assert(!seq.isZero());
00222
00223
00224 typedef typename value_type::ring_type ring_type;
00225 typedef typename ring_type::manager_type manager_type;
00226 value_type result((ring_type)manager_type(m_data));
00227
00228 typename SequenceType::stack_reverse_iterator
00229 start(seq.stackRBegin()), finish(seq.stackREnd());
00230
00231 #ifndef PBORI_NO_TERMS_BY_TAIL
00232 typename BooleSet::navigator navi(result.diagram().navigation());
00233
00234 assert((start == finish) || !start->isConstant());
00235 while((start != finish) &&
00236 (start->elseBranch().isEmpty()) && (start->thenBranch() == navi) ) {
00237 navi = *start;
00238 ++start;
00239 }
00240
00241 result = value_type(dd_type(m_data, navi));
00242 #endif
00243
00244 while (start != finish){
00245 result.changeAssign(**start);
00246 ++start;
00247 }
00248
00249 return result;
00250 }
00251 };
00252
00253
00254 template <>
00255 class CTermGenerator<BooleMonomial>:
00256 public CTermGeneratorBase<BooleMonomial> {
00257 public:
00258 typedef BooleMonomial term_type;
00259 typedef CTermGeneratorBase<term_type> base;
00260 typedef base::data_type data_type;
00261
00262 CTermGenerator(const data_type& data): base(data) {}
00263 CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00264 CTermGenerator(): base() {}
00265 };
00266
00267 END_NAMESPACE_PBORI
00268
00269 #endif