51 Term(): _exponents(0), _varCount(0) {}
52 Term(
const Term& term) {initialize(term._exponents, term._varCount);}
53 Term(
const Exponent* exponents,
size_t varCount) {
54 initialize(exponents, varCount);
63 _exponents = allocate(varCount);
72 Term(
const string& str);
74 ~Term() {deallocate(_exponents, _varCount);}
76 operator Exponent*() {
return _exponents;}
77 operator const Exponent*()
const {
return _exponents;}
79 Exponent* begin() {
return _exponents;}
80 const Exponent* begin()
const {
return _exponents;}
82 Exponent* end() {
return _exponents + _varCount;}
83 const Exponent* end()
const {
return _exponents + _varCount;}
85 size_t getVarCount()
const {
return _varCount;}
89 Exponent operator[](
int offset)
const {
91 ASSERT((
unsigned int)offset < _varCount);
92 return _exponents[offset];
94 Exponent operator[](
unsigned int offset)
const {
95 ASSERT(offset < _varCount);
96 return _exponents[offset];
98 Exponent operator[](
unsigned long offset)
const {
99 ASSERT(offset < _varCount);
100 return _exponents[offset];
102 Exponent operator[](
unsigned long long offset)
const {
103 ASSERT(offset < _varCount);
104 return _exponents[offset];
107 Exponent& operator[](
int offset) {
109 ASSERT((
unsigned int)offset < _varCount);
110 return _exponents[offset];
112 Exponent& operator[](
unsigned int offset) {
113 ASSERT(offset < _varCount);
114 return _exponents[offset];
116 Exponent& operator[](
unsigned long offset) {
117 ASSERT(offset < _varCount);
118 return _exponents[offset];
120 Exponent& operator[](
unsigned long long offset) {
121 ASSERT(offset < _varCount);
122 return _exponents[offset];
125 bool operator==(
const Term& term)
const {
126 ASSERT(_varCount == term._varCount);
127 return (*
this) == term._exponents;
129 bool operator==(
const Exponent* term)
const;
130 bool operator!=(
const Term& term)
const {
return !(*
this == term);}
131 bool operator!=(
const Exponent* term)
const {
return !(*
this == term);}
133 Term& operator=(
const Term& term) {
134 if (_varCount != term._varCount) {
135 Exponent* newBuffer = allocate(term._varCount);
136 deallocate(_exponents, _varCount);
137 _exponents = newBuffer;
138 _varCount = term._varCount;
141 ASSERT(_varCount == term._varCount);
142 return (*
this) = term._exponents;
145 Term& operator=(
const Exponent* exponents) {
146 IF_DEBUG(
if (_varCount > 0))
147 copy(exponents, exponents + _varCount, _exponents);
152 inline static
bool divides(const Exponent* a, const Exponent* b,
size_t varCount) {
153 ASSERT(a != 0 || varCount == 0);
154 ASSERT(b != 0 || varCount == 0);
155 for (
size_t var = 0; var < varCount; ++var)
162 ASSERT(_varCount == term._varCount);
163 return divides(_exponents, term._exponents, _varCount);
166 bool divides(
const Exponent* term)
const {
167 return divides(_exponents, term, _varCount);
172 inline static bool dominates(
const Exponent* a,
const Exponent* b,
174 ASSERT(a != 0 || varCount == 0);
175 ASSERT(b != 0 || varCount == 0);
176 for (
size_t var = 0; var < varCount; ++var)
183 ASSERT(_varCount == term._varCount);
184 return dominates(_exponents, term._exponents, _varCount);
187 bool dominates(
const Exponent* term)
const {
188 return dominates(_exponents, term, _varCount);
198 ASSERT(a != 0 || varCount == 0);
199 ASSERT(b != 0 || varCount == 0);
200 bool bIsIdentity =
true;
201 for (
size_t var = 0; var < varCount; ++var) {
202 if (a[var] >= b[var] && a[var] != 0)
212 ASSERT(_varCount == term._varCount);
221 inline static void lcm(Exponent* res,
222 const Exponent* a,
const Exponent* b,
224 ASSERT(res != 0 || varCount == 0);
225 ASSERT(a != 0 || varCount == 0);
226 ASSERT(b != 0 || varCount == 0);
227 for (
size_t var = 0; var < varCount; ++var) {
235 void lcm(
const Term& a,
const Term& b,
int position) {
236 ASSERT(_varCount == a._varCount);
237 ASSERT(_varCount == b._varCount);
238 lcm(_exponents + position,
239 a._exponents + position,
240 b._exponents + position,
241 _varCount - position);
244 void lcm(
const Term& a,
const Term& b) {
245 ASSERT(_varCount == a._varCount);
246 ASSERT(_varCount == b._varCount);
247 lcm(_exponents, a._exponents, b._exponents, _varCount);
250 void lcm(
const Exponent* a,
const Exponent* b) {
251 lcm(_exponents, a, b, _varCount);
255 inline static void gcd(Exponent* res,
256 const Exponent* a,
const Exponent* b,
258 ASSERT(res != 0 || varCount == 0);
259 ASSERT(a != 0 || varCount == 0);
260 ASSERT(b != 0 || varCount == 0);
261 for (
size_t var = 0; var < varCount; ++var) {
270 ASSERT(_varCount == a._varCount);
271 ASSERT(_varCount == b._varCount);
272 gcd(a._exponents, b._exponents);
275 void gcd(
const Exponent* a,
const Exponent* b) {
276 gcd(_exponents, a, b, _varCount);
281 const Exponent* a,
const Exponent* b,
283 ASSERT(res != 0 || varCount == 0);
284 ASSERT(a != 0 || varCount == 0);
285 ASSERT(b != 0 || varCount == 0);
286 for (
size_t var = 0; var < varCount; ++var)
287 res[var] = a[var] + b[var];
292 ASSERT(_varCount == a._varCount);
293 ASSERT(_varCount == b._varCount);
294 product(_exponents, a._exponents, b._exponents, _varCount);
297 void product(
const Exponent* a,
const Exponent* b) {
298 product(_exponents, a, b, _varCount);
305 ASSERT(res != 0 || varCount == 0);
306 for (
size_t var = 0; var < varCount; ++var)
316 inline static bool isIdentity(
const Exponent* a,
size_t varCount) {
317 ASSERT(a != 0 || varCount == 0);
318 for (
size_t var = 0; var < varCount; ++var)
332 ASSERT(a != 0 || varCount == 0);
333 for (
size_t var = 0; var < varCount; ++var)
347 ASSERT(a != 0 || varCount == 0);
348 for (
size_t var = 0; var < varCount; ++var)
362 ASSERT(a != 0 || varCount == 0);
364 for (
size_t var = 0; var < varCount; ++var) {
366 if (nonZeroOffset == 0)
382 ASSERT(a != 0 || varCount == 0);
384 for (
size_t var = 1; var < varCount; ++var)
394 size_t getMaxExponent()
const {
395 ASSERT(_varCount > 0);
403 ASSERT(a != 0 || varCount == 0);
405 for (
size_t var = 0; var < varCount; ++var)
418 for (
size_t var = 0; var < varCount; ++var)
419 if (a[var] != 0 && a[var] == b[var])
424 inline static size_t getHashCode(
const Exponent* a,
size_t varCount) {
425 size_t hashCode = varCount;
426 for (
size_t var = 0; var < varCount; ++var)
427 hashCode = 31 * hashCode + a[var];
431 size_t getHashCode()
const {
432 return getHashCode(_exponents, _varCount);
448 ASSERT(a != 0 || varCount == 0);
449 ASSERT(b != 0 || varCount == 0);
450 for (
size_t var = 0; var < varCount; ++var) {
464 ASSERT(_varCount == a._varCount);
476 inline static void colon(Exponent* res,
477 const Exponent* a,
const Exponent* b,
479 ASSERT(res != 0 || varCount == 0);
480 ASSERT(a != 0 || varCount == 0);
481 ASSERT(b != 0 || varCount == 0);
482 for (
size_t var = 0; var < varCount; ++var) {
484 res[var] = a[var] - b[var];
491 ASSERT(_varCount == a._varCount);
492 ASSERT(_varCount == b._varCount);
493 colon(a._exponents, b._exponents);
496 void colon(
const Exponent* a,
const Exponent* b) {
497 colon(_exponents, a, b, _varCount);
506 const Exponent* dualOf,
const Exponent* point,
508 ASSERT(res != 0 || varCount == 0);
509 ASSERT(dualOf != 0 || varCount == 0);
510 ASSERT(point != 0 || varCount == 0);
512 for (
size_t var = 0; var < varCount; ++var) {
513 ASSERT(dualOf[var] <= point[var]);
514 if (dualOf[var] != 0)
515 res[var] = point[var] - dualOf[var] + 1;
522 ASSERT(_varCount == dualOf._varCount);
523 ASSERT(_varCount == point._varCount);
527 void encodedDual(
const Exponent* dualOf,
const Exponent* point) {
532 inline static void decrement(Exponent* a,
size_t varCount) {
533 ASSERT(a != 0 || varCount == 0);
534 for (
size_t var = 0; var < varCount; ++var)
543 void swap(Term& term) {
544 std::swap(_varCount, term._varCount);
546 Exponent* tmp = _exponents;
547 _exponents = term._exponents;
548 term._exponents = tmp;
551 void reset(
size_t newVarCount) {
552 if (newVarCount != _varCount) {
553 Exponent* newBuffer = allocate(newVarCount);
555 deallocate(_exponents, _varCount);
556 _varCount = newVarCount;
557 _exponents = newBuffer;
563 deallocate(_exponents, _varCount);
569 static void print(FILE* file,
const Exponent* e,
size_t varCount);
572 static void print(ostream& out,
const Exponent* e,
size_t varCount);
574 void print(FILE* file)
const {
575 print(file, _exponents, _varCount);
578 void print(ostream& out)
const {
579 print(out, _exponents, _varCount);
584 static Exponent* allocate(
size_t size);
585 static void deallocate(Exponent* p,
size_t size);
587 void initialize(
const Exponent* exponents,
size_t varCount) {
589 ASSERT(exponents != 0);
590 _exponents = allocate(varCount);
591 copy(exponents, exponents + varCount, _exponents);
594 _varCount = varCount;
597 Exponent* _exponents;