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>
00084 class CTermGeneratorBase__;
00085
00086
00087 class BooleExponent;
00088 template <class TermType>
00089 class CTermGeneratorBase__<TermType, type_tag<BooleExponent> > {
00090
00091 public:
00092 typedef TermType value_type;
00093 typedef value_type result_type;
00094
00095 template <class SequenceType>
00096 result_type operator()(const SequenceType& seq) const{
00097
00098 value_type result;
00099 result.reserve(seq.deg());
00100 typename SequenceType::const_iterator
00101 start(seq.begin()), finish(seq.end());
00102
00103 while (start != finish){
00104 result.push_back(*start);
00105 ++start;
00106 }
00107 return result;
00108 }
00109 };
00110
00111 template <class TermType>
00112 class CTermGeneratorBase__<TermType, type_tag<CTypes::size_type> > {
00113 public:
00114 typedef TermType value_type;
00115 typedef value_type result_type;
00116
00117 template <class SequenceType>
00118 result_type operator()(const SequenceType& seq) const{
00119 return seq.deg();
00120 }
00121 };
00122
00123
00124 template <class TermType>
00125 class CTermGeneratorBase__<TermType, type_tag<CTypes::deg_type> > {
00126 public:
00127 typedef TermType value_type;
00128 typedef value_type result_type;
00129
00130 template <class SequenceType>
00131 result_type operator()(const SequenceType& seq) const{
00132 return seq.deg();
00133 }
00134 };
00135
00136
00138
00139
00140 template <class TermType>
00141 class CTermGeneratorBase__<TermType, type_tag<BooleMonomial> >{
00142
00143 public:
00144 typedef TermType value_type;
00145 typedef value_type result_type;
00146
00147 typedef CTypes::manager_base manager_base;
00148
00149 typedef CTypes::dd_type dd_type;
00150 typedef dd_type::core_type data_type;
00151
00152
00153 data_type m_data;
00155
00156 CTermGeneratorBase__(const data_type& data): m_data(data) {}
00157
00158 CTermGeneratorBase__(): m_data() {}
00159
00160 template <class SequenceType>
00161 result_type operator()(const SequenceType& seq) const {
00162 assert(m_data != data_type());
00163
00164
00165 assert(!seq.isZero());
00166
00167
00168 typedef typename value_type::ring_type ring_type;
00169 typedef typename ring_type::manager_type manager_type;
00170 value_type result((ring_type)manager_type(m_data));
00171
00172 typename SequenceType::stack_reverse_iterator
00173 start(seq.stackRBegin()), finish(seq.stackREnd());
00174
00175 #ifndef PBORI_NO_TERMS_BY_TAIL
00176 typename BooleSet::navigator navi(result.diagram().navigation());
00177
00178 assert((start == finish) || !start->isConstant());
00179 while((start != finish) &&
00180 (start->elseBranch().isEmpty()) && (start->thenBranch() == navi) ) {
00181 navi = *start;
00182 ++start;
00183 }
00184
00185 result = value_type(dd_type(m_data, navi));
00186 #endif
00187
00188 while (start != finish){
00189 result.changeAssign(**start);
00190 ++start;
00191 }
00192
00193 return result;
00194 }
00195 };
00196
00197
00198 template <class TermType>
00199 class CTermGeneratorBase:
00200 public CTermGeneratorBase__<TermType, type_tag<TermType> > {
00201
00202 };
00203
00204
00205 template <class TermType>
00206 class CTermGenerator:
00207 public CTermGeneratorBase<TermType> {
00208 public:
00209 typedef CTermGeneratorBase<TermType> base;
00210
00211 typedef CTypes::dd_type dd_type;
00212 typedef dd_type::core_type data_type;
00213
00214 CTermGenerator(const data_type&): base() {}
00215 CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00216 CTermGenerator(): base() {}
00217
00218 };
00219
00220
00221 template <>
00222 class CTermGenerator<BooleMonomial>:
00223 public CTermGeneratorBase__<BooleMonomial, type_tag<BooleMonomial> > {
00224 public:
00225 typedef BooleMonomial term_type;
00226 typedef CTermGeneratorBase__<BooleMonomial, type_tag<BooleMonomial> > base;
00227
00228 typedef base::data_type data_type;
00229
00230 CTermGenerator(const data_type& data): base(data) {}
00231 CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
00232 CTermGenerator(): base() {}
00233 };
00234
00235 END_NAMESPACE_PBORI
00236
00237 #endif