PolyBoRi
CTermGenerator.h
Go to the documentation of this file.
1 // -*- c++ -*-
2 //*****************************************************************************
67 //*****************************************************************************
68 
69 // include basic definitions
70 #include "pbori_defs.h"
71 
72 // include polybori functionals
73 #include "pbori_func.h"
74 
75 #include "BooleSet.h"
76 
77 #ifndef CTermGenerator_h_
78 #define CTermGenerator_h_
79 
81 
82 
83 template <class TermType, class BehaviourTag = type_tag<TermType> >
84 class CTermGeneratorBase;
85 
86 #if 0
87 template <class TermType>
88 class CTermGeneratorBase<TermType, type_tag<BooleMonomial> >{
89 
90 public:
91  typedef TermType value_type;
92  typedef value_type result_type;
93 
94  template <class SequenceType>
95  result_type operator()(const SequenceType& seq) const{
96 
97  value_type result(!seq.isZero());
98 
99  typename SequenceType::stack_reverse_iterator
100  start(seq.stackRBegin()), finish(seq.stackREnd());
101 
102 #ifndef PBORI_NO_TERMS_BY_TAIL
103  typename BooleSet::navigator navi(result.diagram().navigation());
104 
105  assert((start == finish) || !start->isConstant());
106  while((start != finish) &&
107  (start->elseBranch().isEmpty()) && (start->thenBranch() == navi) ) {
108  navi = *start;
109  ++start;
110  }
111 
112  result = value_type(BooleSet(navi));
113 #endif
114 
115  while (start != finish){
116  result.changeAssign(**start);
117  ++start;
118  }
119 
120  return result;
121  }
122 };
123 #endif //if0
124 
125 class BooleExponent;
126 template <class TermType>
127 class CTermGeneratorBase<TermType, type_tag<BooleExponent> > {
128 
129 public:
130  typedef TermType value_type;
132 
133  template <class SequenceType>
134  result_type operator()(const SequenceType& seq) const{
135 
136  value_type result;
137  result.reserve(seq.deg());
138  typename SequenceType::const_iterator
139  start(seq.begin()), finish(seq.end());
140 
141  while (start != finish){
142  result.push_back(*start);
143  ++start;
144  }
145  return result;
146  }
147 };
148 
149 template <class TermType>
150 class CTermGeneratorBase<TermType, type_tag<CTypes::size_type> > {
151 public:
152  typedef TermType value_type;
154 
155  template <class SequenceType>
156  result_type operator()(const SequenceType& seq) const{
157  return seq.deg();
158  }
159 };
160 
161 
162 
163 template <class TermType>
165  public CTermGeneratorBase<TermType> {
166 public:
167  typedef CTermGeneratorBase<TermType> base;
168 
171 
173  CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
175 
176 };
177 
179 class NoData {};
180 
181 
182 template <class TermType, class BehaviourTag = type_tag<TermType> >
183 class MyCTermGeneratorBase;
184 
185 template <class TermType>
186 class CTermGeneratorBase<TermType, type_tag<BooleMonomial> >{
187 
188 public:
189  typedef TermType value_type;
191 
193 
196 
197  // typedef CTypes::manager_base data_type;
200 
201  CTermGeneratorBase(const data_type& data): m_data(data) {}
202 
203  CTermGeneratorBase(): m_data() {}
204 
205  template <class SequenceType>
206  result_type operator()(const SequenceType& seq) const {
207  assert(m_data != data_type());
208 
209  // Do not dereference empty sequence (corresponds to end())
210  assert(!seq.isZero());
211 
212  // @todo: avoid using manager_base here
213  typedef typename value_type::ring_type ring_type;
214  typedef typename ring_type::manager_type manager_type;
215  value_type result((ring_type)manager_type(m_data));
216 
217  typename SequenceType::stack_reverse_iterator
218  start(seq.stackRBegin()), finish(seq.stackREnd());
219 
220 #ifndef PBORI_NO_TERMS_BY_TAIL
221  typename BooleSet::navigator navi(result.diagram().navigation());
222 
223  assert((start == finish) || !start->isConstant());
224  while((start != finish) &&
225  (start->elseBranch().isEmpty()) && (start->thenBranch() == navi) ) {
226  navi = *start;
227  ++start;
228  }
229 
230  result = value_type(dd_type(m_data, navi));
231 #endif
232 
233  while (start != finish){
234  result.changeAssign(**start);
235  ++start;
236  }
237 
238  return result;
239  }
240 };
241 
242 
243 template <>
245  public CTermGeneratorBase<BooleMonomial> {
246 public:
248  typedef CTermGeneratorBase<term_type> base;
249  typedef base::data_type data_type;
250 
251  CTermGenerator(const data_type& data): base(data) {}
252  CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
254 };
255 
257 
258 #endif