Frobby  0.9.1
frobby.cpp
Go to the documentation of this file.
1 /* Frobby: Software for monomial ideal computations.
2  Copyright (C) 2007 Bjarke Hammersholt Roune (www.broune.com)
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; either version 2 of the License, or
7  (at your option) any later version.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program. If not, see http://www.gnu.org/licenses/.
16 */
17 #include "stdinc.h"
18 #include "frobby.h"
19 
20 #include "BigIdeal.h"
21 #include "SliceFacade.h"
22 #include "BigTermConsumer.h"
23 #include "TermTranslator.h"
24 #include "Term.h"
25 #include "error.h"
26 #include "CoefBigTermConsumer.h"
27 #include "IdealFacade.h"
28 #include "SliceParams.h"
29 
31 protected:
32  ConsumerWrapper(size_t varCount):
33  _varCount(varCount),
34  _term(new mpz_ptr[varCount]) {
35  }
36 
37  virtual ~ConsumerWrapper() {
38  delete[] _term;
39  }
40 
41  void setTerm(const Term& term, const TermTranslator& translator) {
42  ASSERT(term.getVarCount() == _varCount);
43  ASSERT(translator.getVarCount() == _varCount);
44 
45  for (size_t var = 0; var < _varCount; ++var)
46  _term[var] = const_cast<mpz_ptr>
47  (translator.getExponent(var, term).get_mpz_t());
48  }
49 
50  void setTerm(const vector<mpz_class>& term) {
51  ASSERT(term.size() == _varCount);
52 
53  for (size_t var = 0; var < _varCount; ++var)
54  _term[var] = const_cast<mpz_ptr>(term[var].get_mpz_t());
55  }
56 
57  size_t _varCount;
58  mpz_ptr* _term;
59 };
60 
62  public ConsumerWrapper {
63 public:
65  size_t varCount):
66  ConsumerWrapper(varCount),
67  _consumer(consumer) {
68  ASSERT(_consumer != 0);
69  }
70 
71  virtual void consumeRing(const VarNames& names) {
72  ASSERT(names.getVarCount() == _varCount);
73  }
74 
75  virtual void beginConsuming() {
77  }
78 
79  virtual void consume(const Term& term, const TermTranslator& translator) {
80  ASSERT(term.getVarCount() == _varCount);
81  ASSERT(translator.getVarCount() == _varCount);
82 
83  setTerm(term, translator);
85  }
86 
87  virtual void consume(const vector<mpz_class>& term) {
88  ASSERT(term.size() == _varCount);
89 
90  setTerm(term);
92  }
93 
94  virtual void doneConsuming() {
96  }
97 
98 private:
100 };
101 
103  public ConsumerWrapper {
104 public:
106  size_t varCount):
107  ConsumerWrapper(varCount),
108  _consumer(consumer),
109  _varCount(varCount) {
110  ASSERT(consumer != 0);
111  }
112 
113  virtual void consumeRing(const VarNames& names) {
114  ASSERT(names.getVarCount() == _varCount);
115  }
116 
117  virtual void beginConsuming() {
119  }
120 
121  virtual void consume(const mpz_class& coef,
122  const Term& term,
123  const TermTranslator& translator) {
124  ASSERT(term.getVarCount() == _varCount);
125  ASSERT(translator.getVarCount() == _varCount);
126 
127  setTerm(term, translator);
128  _consumer->consume(coef.get_mpz_t(), _term);
129  }
130 
131  virtual void consume(const mpz_class& coef,
132  const vector<mpz_class>& term) {
133  ASSERT(term.size() == _varCount);
134 
135  for (size_t var = 0; var < _varCount; ++var)
136  _term[var] = const_cast<mpz_ptr>(term[var].get_mpz_t());
137  _consumer->consume(coef.get_mpz_t(), _term);
138  }
139 
140  // TODO: make a note somewhere that in case of an exception,
141  // polynomialEnd might not get called, this being because it is too
142  // much of a burden to require it not to throw any
143  // exceptions. Hmm... maybe there is an alternative solution.
144  virtual void doneConsuming() {
146  }
147 
148 private:
150  size_t _varCount;
151 };
152 
154 }
155 
156 void Frobby::IdealConsumer::idealBegin(size_t varCount) {
157 }
158 
160 }
161 
163 }
164 
166 }
167 
169 }
170 
171 namespace FrobbyImpl {
172  using ::BigIdeal;
173 
175  public:
176  FrobbyIdealHelper(size_t variableCount):
177  _ideal(VarNames(variableCount)),
178  _atVariable(variableCount) {
179  }
180 
181  static const BigIdeal& getIdeal(const Frobby::Ideal& ideal) {
182  return ideal._data->_ideal;
183  }
184 
185  private:
186  friend class Frobby::Ideal;
187 
189  size_t _atVariable;
190  };
191 }
192 
193 Frobby::Ideal::Ideal(size_t variableCount) {
194  _data = new FrobbyImpl::FrobbyIdealHelper(variableCount);
195 }
196 
199 }
200 
202  delete _data;
203 }
204 
206  // Allocate new object before deleting old object to leave *this
207  // in a valid state in case of new throwing an exception.
210 
211  delete _data;
212  _data = newValue;
213 
214  return *this;
215 }
216 
217 void Frobby::Ideal::addExponent(const mpz_t exponent) {
219 
222  _data->_atVariable = 0;
223  if (_data->_ideal.getVarCount() == 0)
224  return;
225  }
226 
228  mpz_set(ref.get_mpz_t(), exponent);
229  ++_data->_atVariable;
230 }
231 
232 void Frobby::Ideal::addExponent(int exponent) {
233  mpz_class tmp(exponent);
234  addExponent(tmp.get_mpz_t());
235 }
236 
237 void Frobby::Ideal::addExponent(unsigned int exponent) {
238  mpz_class tmp(exponent);
239  addExponent(tmp.get_mpz_t());
240 }
241 
242 bool Frobby::alexanderDual(const Ideal& ideal,
243  const mpz_t* reflectionMonomial,
244  IdealConsumer& consumer) {
245  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
246 
247  ExternalIdealConsumerWrapper wrappedConsumer
248  (&consumer, bigIdeal.getVarCount());
249 
250  SliceParams params;
251  SliceFacade facade(params, bigIdeal, wrappedConsumer);
252 
253  if (reflectionMonomial == 0)
254  facade.computeAlexanderDual();
255  else {
256  vector<mpz_class> point;
257  point.resize(bigIdeal.getVarCount());
258  for (size_t var = 0; var < bigIdeal.getVarCount(); ++var)
259  mpz_set(point[var].get_mpz_t(), reflectionMonomial[var]);
260 
261  // We guarantee not to retain a reference to reflectionMonomial
262  // when providing terms to the consumer.
263  reflectionMonomial = 0;
264 
265  try {
266  facade.computeAlexanderDual(point);
267  } catch (const FrobbyException&) {
268  return false;
269  }
270  }
271 
272  return true;
273 }
274 
275 bool Frobby::alexanderDual(const Ideal& ideal,
276  const Ideal& reflectionMonomial,
277  IdealConsumer& consumer) {
278  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
279  const BigIdeal& reflectionIdeal =
280  FrobbyImpl::FrobbyIdealHelper::getIdeal(reflectionMonomial);
281 
282  if (reflectionIdeal.getGeneratorCount() != 1)
283  return false;
284  if (reflectionIdeal.getVarCount() != bigIdeal.getVarCount())
285  return false;
286 
287  const vector<mpz_class>& monomial = reflectionIdeal.getTerm(0);
288  const mpz_t* monomialPtr = 0;
289  if (reflectionIdeal.getVarCount() > 0)
290  monomialPtr = (const mpz_t*)&(monomial[0]);
291 
292  return alexanderDual(ideal, monomialPtr, consumer);
293 }
294 
296  PolynomialConsumer& consumer) {
297  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
298 
299  ExternalPolynomialConsumerWrapper wrappedConsumer
300  (&consumer, bigIdeal.getVarCount());
301  SliceParams params;
302  SliceFacade facade(params, bigIdeal, wrappedConsumer);
303 
305 }
306 
308  PolynomialConsumer& consumer) {
309  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
310 
311  ExternalPolynomialConsumerWrapper wrappedConsumer(&consumer, 1);
312  SliceParams params;
313  SliceFacade facade(params, bigIdeal, wrappedConsumer);
314 
316 }
317 
322 public:
323  IrreducibleIdealDecoder(IdealConsumer* consumer):
324  _varCount(0),
325  _consumer(consumer),
326  _term(0) {
327  ASSERT(_consumer != 0);
328  }
329 
331  }
332 
333  virtual void idealBegin(size_t varCount) {
334  _varCount = varCount;
335  _term.resize(varCount);
336  for (size_t var = 0; var < _varCount; ++var)
337  _term[var] = _zero.get_mpz_t();
338  }
339 
340  virtual void idealEnd() {
341  _term.clear();
342  }
343 
344  virtual void consume(mpz_ptr* exponentVector) {
345  _consumer->idealBegin(_varCount);
346 
347  bool isIdentity = true;
348  for (size_t var = 0; var < _varCount; ++var) {
349  if (mpz_cmp_ui(exponentVector[var], 0) != 0) {
350  isIdentity = false;
351  _term[var] = exponentVector[var];
352  _consumer->consume(&*(_term.begin()));
353  _term[var] = _zero.get_mpz_t();
354  }
355  }
356 
357  _consumer->idealEnd();
358  }
359 
360 private:
361  size_t _varCount;
362  IdealConsumer* _consumer;
363  vector<mpz_ptr> _term;
364  mpz_class _zero;
365 };
366 
368  IdealConsumer& consumer) {
369  IrreducibleIdealDecoder wrappedConsumer(&consumer);
370  if (!irreducibleDecompositionAsMonomials(ideal, wrappedConsumer)) {
371  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
372  consumer.idealBegin(bigIdeal.getVarCount());
373  consumer.idealEnd();
374  }
375 }
376 
378  IdealConsumer& consumer) {
379  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
380  if (bigIdeal.getGeneratorCount() == 0)
381  return false;
382 
383  ExternalIdealConsumerWrapper wrappedConsumer
384  (&consumer, bigIdeal.getVarCount());
385  SliceParams params;
386  SliceFacade facade(params, bigIdeal, wrappedConsumer);
387 
388  facade.computeIrreducibleDecomposition(true);
389  return true;
390 }
391 
393  IdealConsumer& consumer) {
394  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
395 
396  ExternalIdealConsumerWrapper wrappedConsumer
397  (&consumer, bigIdeal.getVarCount());
398  SliceParams params;
399  SliceFacade facade(params, bigIdeal, wrappedConsumer);
400 
402 }
403 
405  IdealConsumer& consumer) {
406  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
407 
408  ExternalIdealConsumerWrapper wrappedConsumer
409  (&consumer, bigIdeal.getVarCount());
410  SliceParams params;
411  SliceFacade facade(params, bigIdeal, wrappedConsumer);
412 
414 }
415 
417  const mpz_t* l,
418  IdealConsumer& consumer) {
419  ASSERT(l != 0);
420 
421  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
422 
423  vector<mpz_class> grading;
424  for (size_t var = 0; var < bigIdeal.getVarCount(); ++var)
425  grading.push_back(mpz_class(l[var]));
426 
427  ExternalIdealConsumerWrapper wrappedConsumer
428  (&consumer, bigIdeal.getVarCount());
429  SliceParams params;
430  params.useIndependenceSplits(false); // not supported
431  SliceFacade facade(params, bigIdeal, wrappedConsumer);
432 
433  mpz_class dummy;
434  return facade.solveStandardProgram(grading, dummy, false);
435 }
436 
437 void Frobby::codimension(const Ideal& ideal, mpz_t codim) {
438  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
439  dimension(ideal, codim);
440  mpz_ui_sub(codim, bigIdeal.getVarCount(), codim);
441 }
442 
443 void Frobby::dimension(const Ideal& ideal, mpz_t dim) {
444  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
445 
446  IdealFacade facade(false);
447  mpz_class dimen = facade.computeDimension(bigIdeal, false);
448  mpz_set(dim, dimen.get_mpz_t());
449 }
450 
451 void Frobby::associatedPrimes(const Ideal& ideal, IdealConsumer& consumer) {
452  const BigIdeal& bigIdeal = FrobbyImpl::FrobbyIdealHelper::getIdeal(ideal);
453  IrreducibleIdealDecoder decodingConsumer(&consumer);
454 
455  ExternalIdealConsumerWrapper wrappedConsumer
456  (&decodingConsumer, bigIdeal.getVarCount());
457  SliceParams params;
458  SliceFacade facade(params, bigIdeal, wrappedConsumer);
459 
460  facade.computeAssociatedPrimes();
461 }
FrobbyImpl::FrobbyIdealHelper::getIdeal
static const BigIdeal & getIdeal(const Frobby::Ideal &ideal)
Definition: frobby.cpp:181
Frobby::PolynomialConsumer::polynomialEnd
virtual void polynomialEnd()
Called after output of a polynomial.
Definition: frobby.cpp:168
BigIdeal
Definition: BigIdeal.h:27
ExternalIdealConsumerWrapper::_consumer
Frobby::IdealConsumer * _consumer
Definition: frobby.cpp:99
CoefBigTermConsumer
Definition: CoefBigTermConsumer.h:29
SliceFacade::computeMultigradedHilbertSeries
void computeMultigradedHilbertSeries()
Compute the numerator of the multigraded Hilbert-Poincare series.
Definition: SliceFacade.cpp:78
Frobby::dimension
void dimension(const Ideal &ideal, mpz_t dim)
Compute the Krull dimension of a monomial ideal.
Definition: frobby.cpp:443
IdealFacade::computeDimension
mpz_class computeDimension(const BigIdeal &ideal, bool codimension=false, bool squareFreeAndMinimal=false)
Compute the Krull dimension of ideal.
Definition: IdealFacade.cpp:82
Frobby::PolynomialConsumer::polynomialBegin
virtual void polynomialBegin(size_t varCount)
Called before output of a polynomial.
Definition: frobby.cpp:165
FrobbyImpl::FrobbyIdealHelper::_atVariable
size_t _atVariable
Definition: frobby.cpp:189
stdinc.h
frobby.h
ExternalIdealConsumerWrapper::doneConsuming
virtual void doneConsuming()
Must be called once after each time beginConsuming has been called.
Definition: frobby.cpp:94
ExternalIdealConsumerWrapper::beginConsuming
virtual void beginConsuming()
Tell the consumer to begin consuming an ideal.
Definition: frobby.cpp:75
BigTermConsumer.h
Frobby::PolynomialConsumer::~PolynomialConsumer
virtual ~PolynomialConsumer()
The provided implementation does nothing.
Definition: frobby.cpp:162
ExternalPolynomialConsumerWrapper::_varCount
size_t _varCount
Definition: frobby.cpp:150
Frobby::IdealConsumer::idealEnd
virtual void idealEnd()
Called after output of a monomial ideal.
Definition: frobby.cpp:159
IrreducibleIdealDecoder::_term
vector< mpz_ptr > _term
Definition: frobby.cpp:363
Frobby::Ideal::~Ideal
~Ideal()
Definition: frobby.cpp:201
IrreducibleIdealDecoder::_consumer
IdealConsumer * _consumer
Definition: frobby.cpp:362
ExternalPolynomialConsumerWrapper::consume
virtual void consume(const mpz_class &coef, const Term &term, const TermTranslator &translator)
Definition: frobby.cpp:121
FrobbyImpl::FrobbyIdealHelper
Definition: frobby.cpp:174
Term::getVarCount
size_t getVarCount() const
Definition: Term.h:85
IrreducibleIdealDecoder::idealEnd
virtual void idealEnd()
Called after output of a monomial ideal.
Definition: frobby.cpp:340
Frobby::IdealConsumer::consume
virtual void consume(mpz_ptr *exponentVector)=0
For output of a generator of the ideal.
IrreducibleIdealDecoder::consume
virtual void consume(mpz_ptr *exponentVector)
For output of a generator of the ideal.
Definition: frobby.cpp:344
Frobby::maximalStandardMonomials
void maximalStandardMonomials(const Ideal &ideal, IdealConsumer &consumer)
Compute the maximal standard monomials of ideal.
Definition: frobby.cpp:404
BigIdeal::newLastTerm
void newLastTerm()
Definition: BigIdeal.cpp:104
Frobby::irreducibleDecompositionAsMonomials
bool irreducibleDecompositionAsMonomials(const Ideal &ideal, IdealConsumer &consumer)
Compute the irreducible decomposition of ideal, and encode each irreducible component as a monomial.
Definition: frobby.cpp:377
ExternalPolynomialConsumerWrapper
Definition: frobby.cpp:102
Term.h
FrobbyImpl::FrobbyIdealHelper::_ideal
BigIdeal _ideal
Definition: frobby.cpp:188
TermTranslator
TermTranslator handles translation between terms whose exponents are infinite precision integers and ...
Definition: TermTranslator.h:41
BigIdeal::getTerm
const vector< mpz_class > & getTerm(size_t term) const
Definition: BigIdeal.h:139
ConsumerWrapper::setTerm
void setTerm(const vector< mpz_class > &term)
Definition: frobby.cpp:50
ConsumerWrapper::_term
mpz_ptr * _term
Definition: frobby.cpp:58
TermTranslator::getExponent
const mpz_class & getExponent(size_t variable, Exponent exponent) const
This method translates from IDs to arbitrary precision integers.
Definition: TermTranslator.cpp:392
Frobby::multigradedHilbertPoincareSeries
void multigradedHilbertPoincareSeries(const Ideal &ideal, PolynomialConsumer &consumer)
Compute the multigraded Hilbert-Poincare series of ideal.
Definition: frobby.cpp:295
TermTranslator::getVarCount
size_t getVarCount() const
Definition: TermTranslator.cpp:447
Frobby::Ideal::_data
FrobbyImpl::FrobbyIdealHelper * _data
Definition: frobby.h:60
SliceFacade::computeMaximalStandardMonomials
void computeMaximalStandardMonomials()
Compute the maximal standard monomials of the ideal.
Definition: SliceFacade.cpp:241
Frobby::Ideal::operator=
Ideal & operator=(const Ideal &ideal)
Definition: frobby.cpp:205
VarNames::getVarCount
size_t getVarCount() const
Returns the current number of variables.
Definition: VarNames.h:113
ConsumerWrapper
Definition: frobby.cpp:30
SliceFacade::solveStandardProgram
bool solveStandardProgram(const vector< mpz_class > &grading, mpz_class &value, bool reportAllSolutions)
Solve an optimization program over maximal standard monomials.
Definition: SliceFacade.cpp:352
Frobby::PolynomialConsumer::consume
virtual void consume(const mpz_t coefficient, mpz_ptr *exponentVector)=0
For output of a term of the polynomial.
BigIdeal::getLastTermExponentRef
mpz_class & getLastTermExponentRef(size_t var)
Definition: BigIdeal.h:126
SliceFacade::computeAssociatedPrimes
void computeAssociatedPrimes()
Compute the associated primes of the ideal.
Definition: SliceFacade.cpp:286
IrreducibleIdealDecoder::_varCount
size_t _varCount
Definition: frobby.cpp:361
Frobby::univariateHilbertPoincareSeries
void univariateHilbertPoincareSeries(const Ideal &ideal, PolynomialConsumer &consumer)
Compute the univariate Hilbert-Poincare series of ideal.
Definition: frobby.cpp:307
ConsumerWrapper::ConsumerWrapper
ConsumerWrapper(size_t varCount)
Definition: frobby.cpp:32
SliceParams
Definition: SliceParams.h:25
IrreducibleIdealDecoder::IrreducibleIdealDecoder
IrreducibleIdealDecoder(IdealConsumer *consumer)
Definition: frobby.cpp:323
Term
Term represents a product of variables which does not include a coefficient.
Definition: Term.h:49
Frobby::irreducibleDecompositionAsIdeals
void irreducibleDecompositionAsIdeals(const Ideal &ideal, IdealConsumer &consumer)
Compute the irreducible decomposition of ideal.
Definition: frobby.cpp:367
error.h
IdealFacade.h
SliceFacade.h
BigTermConsumer
Definition: BigTermConsumer.h:29
Frobby::solveStandardMonomialProgram
bool solveStandardMonomialProgram(const Ideal &ideal, const mpz_t *l, IdealConsumer &consumer)
Solve the optimization program.
Definition: frobby.cpp:416
Frobby::alexanderDual
bool alexanderDual(const Ideal &ideal, const mpz_t *reflectionMonomial, IdealConsumer &consumer)
Compute the Alexander dual of ideal using the point reflectionMonomial.
Definition: frobby.cpp:242
ConsumerWrapper::setTerm
void setTerm(const Term &term, const TermTranslator &translator)
Definition: frobby.cpp:41
FrobbyImpl::FrobbyIdealHelper::FrobbyIdealHelper
FrobbyIdealHelper(size_t variableCount)
Definition: frobby.cpp:176
Frobby::IdealConsumer
This class provides a way to get monomial ideals as output from Frobby one generator at a time.
Definition: frobby.h:73
IrreducibleIdealDecoder::idealBegin
virtual void idealBegin(size_t varCount)
Called before output of a monomial ideal.
Definition: frobby.cpp:333
ExternalIdealConsumerWrapper::consume
virtual void consume(const vector< mpz_class > &term)
Definition: frobby.cpp:87
Frobby::codimension
void codimension(const Ideal &ideal, mpz_t codim)
Compute the codimension of a monomial ideal.
Definition: frobby.cpp:437
ConsumerWrapper::~ConsumerWrapper
virtual ~ConsumerWrapper()
Definition: frobby.cpp:37
ExternalIdealConsumerWrapper::ExternalIdealConsumerWrapper
ExternalIdealConsumerWrapper(Frobby::IdealConsumer *consumer, size_t varCount)
Definition: frobby.cpp:64
Frobby::IdealConsumer::idealBegin
virtual void idealBegin(size_t varCount)
Called before output of a monomial ideal.
Definition: frobby.cpp:156
ExternalPolynomialConsumerWrapper::doneConsuming
virtual void doneConsuming()
Definition: frobby.cpp:144
SliceParams::useIndependenceSplits
void useIndependenceSplits(bool value)
Definition: SliceParams.h:34
SliceParams.h
ExternalIdealConsumerWrapper::consumeRing
virtual void consumeRing(const VarNames &names)
Tell the consumer which ring is being used.
Definition: frobby.cpp:71
Frobby::associatedPrimes
void associatedPrimes(const Ideal &ideal, IdealConsumer &consumer)
Compute the associated primes of the ideal.
Definition: frobby.cpp:451
IrreducibleIdealDecoder::_zero
mpz_class _zero
Definition: frobby.cpp:364
Frobby::Ideal
Definition: frobby.h:33
Frobby::primaryDecomposition
void primaryDecomposition(const Ideal &ideal, IdealConsumer &consumer)
Compute the canonical primary decomposition of a monomial ideal.
Definition: frobby.cpp:392
Frobby::IdealConsumer::~IdealConsumer
virtual ~IdealConsumer()
The provided implementation does nothing.
Definition: frobby.cpp:153
FrobbyException
This is the base of the Frobby exception hierarchy for exceptions that can occur due to expected erro...
Definition: error.h:27
SliceFacade::computeUnivariateHilbertSeries
void computeUnivariateHilbertSeries()
Compute the numerator of the univariate Hilbert-Poincare series.
Definition: SliceFacade.cpp:93
ExternalPolynomialConsumerWrapper::_consumer
Frobby::PolynomialConsumer * _consumer
Definition: frobby.cpp:149
SliceFacade::computeIrreducibleDecomposition
void computeIrreducibleDecomposition(bool encode)
Compute the unique irredundant set of irreducible ideals whose intersection equals ideal.
Definition: SliceFacade.cpp:109
ExternalPolynomialConsumerWrapper::consume
virtual void consume(const mpz_class &coef, const vector< mpz_class > &term)
Definition: frobby.cpp:131
TermTranslator.h
Frobby::Ideal::Ideal
Ideal(size_t variableCount)
Definition: frobby.cpp:193
ExternalPolynomialConsumerWrapper::ExternalPolynomialConsumerWrapper
ExternalPolynomialConsumerWrapper(Frobby::PolynomialConsumer *consumer, size_t varCount)
Definition: frobby.cpp:105
ExternalPolynomialConsumerWrapper::beginConsuming
virtual void beginConsuming()
Definition: frobby.cpp:117
CoefBigTermConsumer.h
IdealFacade
A facade for performing operations on BigIdeal.
Definition: IdealFacade.h:34
ConsumerWrapper::_varCount
size_t _varCount
Definition: frobby.cpp:57
ExternalIdealConsumerWrapper
Definition: frobby.cpp:61
IrreducibleIdealDecoder::~IrreducibleIdealDecoder
~IrreducibleIdealDecoder()
Definition: frobby.cpp:330
VarNames
Defines the variables of a polynomial ring and facilities IO involving them.
Definition: VarNames.h:40
ExternalIdealConsumerWrapper::consume
virtual void consume(const Term &term, const TermTranslator &translator)
Definition: frobby.cpp:79
ASSERT
#define ASSERT(X)
Definition: stdinc.h:86
FrobbyImpl
The namespace FrobbyImpl is for internal use inside Frobby only.
Definition: frobby.cpp:171
BigIdeal::getGeneratorCount
size_t getGeneratorCount() const
Definition: BigIdeal.h:144
IrreducibleIdealDecoder
Definition: frobby.cpp:321
ExternalPolynomialConsumerWrapper::consumeRing
virtual void consumeRing(const VarNames &names)
Definition: frobby.cpp:113
SliceFacade
A facade for operations on monomial ideals using the Slice Algorithm.
Definition: SliceFacade.h:44
Frobby::Ideal::addExponent
void addExponent(const mpz_t exponent)
Call addExponent once for each variable to add a term one exponent at a time.
Definition: frobby.cpp:217
SliceFacade::computePrimaryDecomposition
void computePrimaryDecomposition()
Compute the unique "nicest" primary decomposition of the ideal.
Definition: SliceFacade.cpp:150
BigIdeal.h
BigIdeal::getVarCount
size_t getVarCount() const
Definition: BigIdeal.h:148
SliceFacade::computeAlexanderDual
void computeAlexanderDual(const vector< mpz_class > &point)
Compute the Alexander dual of the ideal.
Definition: SliceFacade.cpp:250
SquareFreeTermOps::isIdentity
bool isIdentity(const Word *a, Word *aEnd)
Definition: RawSquareFreeTerm.cpp:51
Frobby::PolynomialConsumer
This class provides a way to get polynomials as output from Frobby one term at a time.
Definition: frobby.h:110