TermTranslator.h

Go to the documentation of this file.

/* Frobby: Software for monomial ideal computations.
   Copyright (C) 2007 Bjarke Hammersholt Roune (www.broune.com)
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see http://www.gnu.org/licenses/.
*/
#ifndef TERM_TRANSLATOR_GUARD
#define TERM_TRANSLATOR_GUARD
 
#include "VarNames.h"
 
#include <vector>
#include <ostream>
 
class BigIdeal;
class Ideal;
class Term;
 
class TermTranslator {
public:
  TermTranslator(size_t varCount, size_t upToExponent);
 
  TermTranslator(const BigIdeal& bigIdeal, Ideal& ideal, bool sortVars = true);
 
  TermTranslator(const vector<BigIdeal*>& bigIdeals, vector<Ideal*>& ideals);
 
  TermTranslator(const TermTranslator& translator);
  ~TermTranslator();
 
  TermTranslator& operator=(const TermTranslator& translator);
 
  const mpz_class& getExponent(size_t variable, Exponent exponent) const;
 
  const mpz_class& getExponent(size_t variable, const Term& term) const;
 
  const char* getVarExponentString(size_t variable, Exponent exponent) const;
 
  const char* getExponentString(size_t variable, Exponent exponent) const;
 
  Exponent getMaxId(size_t variable) const;
 
  void addPurePowersAtInfinity(Ideal& ideal) const;
 
  void setInfinityPowersToZero(Ideal& ideal) const;
 
  const VarNames& getNames() const;
  size_t getVarCount() const;
 
  void dualize(const vector<mpz_class>& a);
 
  void decrement();
 
  void renameVariables(const VarNames& names);
  void swapVariables(size_t a, size_t b);
 
  bool lessThanReverseLex(const Exponent* a, const Exponent* b) const;
 
  void print(ostream& out) const;
  string toString() const;
 
private:
  void makeStrings(bool includeVar) const;
  void clearStrings();
 
  void initialize(const vector<BigIdeal*>& bigIdeals, bool sortVars);
  void shrinkBigIdeal(const BigIdeal& bigIdeal, Ideal& ideal) const;
  Exponent shrinkExponent(size_t var, const mpz_class& exponent) const;
 
  vector<vector<mpz_class> > _exponents;
  mutable vector<vector<const char*> > _stringExponents;
  mutable vector<vector<const char*> > _stringVarExponents;
  VarNames _names;
};
 
class TranslatedReverseLexComparator {
 public:
 TranslatedReverseLexComparator(const TermTranslator& translator):
  _translator(translator) {
  }
 
  bool operator()(const Term& a, const Term& b) const;
  bool operator()(const Exponent* a, const Exponent* b) const;
 
 private:
  const TermTranslator& _translator;
};
 
void setToZeroOne(TermTranslator& translator);
 
ostream& operator<<(ostream& out, const TermTranslator& translator);
 
#endif