/usr/include/polybori/iterators/CTermGenerator.h is in libpolybori-dev 0.8.3-5build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 | // -*- c++ -*-
//*****************************************************************************
/** @file CTermGenerator.h
*
* @author Alexander Dreyer
* @date 2007-05-03
*
* Defines the template class CTermGenerator, which is a functional for
* generation of from from a sequence of indices.
*
* @par Copyright:
* (c) 2007-2010 by The PolyBoRi Team
*
**/
//*****************************************************************************
#ifndef polybori_iterators_CTermGenerator_h_
#define polybori_iterators_CTermGenerator_h_
// include basic definitions
#include <polybori/pbori_defs.h>
// include polybori functionals
#include <polybori/routines/pbori_func.h>
//#include <polybori/BooleSet.h>
BEGIN_NAMESPACE_PBORI
template <class TermType, class BehaviourTag>
class CTermGeneratorBase__;
class BooleExponent;
template <class TermType>
class CTermGeneratorBase__<TermType, type_tag<BooleExponent> > {
public:
typedef TermType value_type;
typedef value_type result_type;
template <class SequenceType>
result_type operator()(const SequenceType& seq) const{
value_type result;
result.reserve(seq.deg());
typename SequenceType::const_iterator
start(seq.begin()), finish(seq.end());
while (start != finish){
result.push_back(*start);
++start;
}
return result;
}
};
template <class TermType>
class CTermGeneratorBase__<TermType, type_tag<CTypes::size_type> > {
public:
typedef TermType value_type;
typedef value_type result_type;
template <class SequenceType>
result_type operator()(const SequenceType& seq) const{
return seq.deg();
}
};
template <class TermType>
class CTermGeneratorBase__<TermType, type_tag<CTypes::deg_type> > {
public:
typedef TermType value_type;
typedef value_type result_type;
template <class SequenceType>
result_type operator()(const SequenceType& seq) const{
return seq.deg();
}
};
/////////
template <class TermType>
class CTermGeneratorBase__<TermType, type_tag<BooleMonomial> >{
public:
typedef TermType value_type;
typedef value_type result_type;
// typedef CTypes::manager_base manager_base;
typedef BoolePolyRing data_type;
typedef data_type::dd_type dd_type;
// typedef CTypes::manager_base data_type;
data_type m_data;
///CCuddCore * m_data; // non-save variant
CTermGeneratorBase__(const data_type& data): m_data(data) {}
CTermGeneratorBase__(): m_data() {}
template <class SequenceType>
result_type operator()(const SequenceType& seq) const {
/// PBORI_ASSERT(m_data != data_type()); // todo???
// Do not dereference empty sequence (corresponds to end())
PBORI_ASSERT(!seq.isZero());
// @todo: avoid using manager_base here
typedef typename value_type::ring_type ring_type;
/// typedef typename ring_type::manager_type manager_type;
// value_type result((ring_type)manager_type(m_data));
value_type result((ring_type)(m_data));
typename SequenceType::stack_reverse_iterator
start(seq.stackRBegin()), finish(seq.stackREnd());
#ifndef PBORI_NO_TERMS_BY_TAIL
typename BooleSet::navigator navi(result.diagram().navigation());
PBORI_ASSERT((start == finish) || !start->isConstant());
while((start != finish) &&
(start->elseBranch().isEmpty()) && (start->thenBranch() == navi) ) {
navi = *start;
++start;
}
result = value_type(dd_type(m_data, navi));
#endif
while (start != finish){
result = result.change(**start);
++start;
}
return result;
}
};
template <class TermType>
class CTermGeneratorBase:
public CTermGeneratorBase__<TermType, type_tag<TermType> > {
};
template <class TermType>
class CTermGenerator:
public CTermGeneratorBase<TermType> {
public:
typedef CTermGeneratorBase<TermType> base;
typedef BoolePolyRing data_type;
CTermGenerator(const data_type&): base() {}
CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
CTermGenerator(): base() {}
};
template <>
class CTermGenerator<BooleMonomial>:
public CTermGeneratorBase__<BooleMonomial, type_tag<BooleMonomial> > {
public:
typedef BooleMonomial term_type;
typedef CTermGeneratorBase__<BooleMonomial, type_tag<BooleMonomial> > base;
//typedef CTermGeneratorBase<term_type> base;
typedef base::data_type data_type;
CTermGenerator(const data_type& data): base(data) {}
CTermGenerator(const CTermGenerator& rhs): base(rhs) {}
// CTermGenerator(): base() {}
};
END_NAMESPACE_PBORI
#endif
|