OptimizeStrategy.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 OPTIMIZE_STRATEGY_GUARD
#define OPTIMIZE_STRATEGY_GUARD
 
#include "MsmStrategy.h"
#include "Term.h"
#include "TermConsumer.h"
#include "tests.h"
 
class Slice;
class TermGrader;
 
class OptimizeStrategy : public MsmStrategy, public TermConsumer {
public:
  enum BoundSetting {
    DoNotUseBound,
 
    UseBoundToEliminate,
 
    UseBoundToEliminateAndSimplify
  };
 
  OptimizeStrategy(TermGrader& grader,
                   const SplitStrategy* splitStrategy,
                   bool reportAllSolutions,
                   BoundSetting boundSetting);
 
  const Ideal& getMaximalSolutions();
 
  const mpz_class& getMaximalValue();
 
  virtual void setUseIndependence(bool use);
 
  virtual void getPivot(Term& pivot, Slice& slice);
 
  virtual bool simplify(Slice& slice);
 
  virtual void beginConsuming();
  virtual void consume(const Term& term);
  virtual void doneConsuming();
 
 private:
  bool changedInWayRelevantToBound
    (const Term& oldDivisor, const Term& oldDominator,
     const Term& newDivisor, const Term& newDominator) const;
 
  bool boundSimplify
    (Slice& slice,
     const Term& dominator,
     const mpz_class& upperBound);
 
  bool getInnerSimplify
    (const Term& divisor,
     const Term& dominator,
     const mpz_class& upperBound,
     Term& pivot);
 
  bool getOuterSimplify
    (const Term& divisor,
     const Term& dominator,
     const mpz_class& upperBound,
     Term& pivot);
 
  bool getDominator(Slice& slice, Term& dominator);
 
  size_t getVarCount() const;
 
  const TermGrader& _grader;
 
  mpz_class _maxValue;
 
  mpz_class _maxValueToBeat;
 
  Ideal _maxSolutions;
 
  bool _reportAllSolutions;
 
  BoundSetting _boundSetting;
 
  mpz_class _consume_tmpDegree;
 
  mpz_class _simplify_tmpUpperBound;
 
  Term _simplify_tmpDominator;
 
  Term _simplify_tmpOldDominator;
 
  Term _simplify_tmpOldDivisor;
 
  mpz_class _tmpC;
 
  Term _boundSimplify_tmpPivot;
 
 
  FRIEND_TEST(OptimizeStrategy, ChangedInWayRelevantToBound);
  FRIEND_TEST(OptimizeStrategy, SimplifyPositiveGrading);
  FRIEND_TEST(OptimizeStrategy, SimplifyNegativeGrading);
};
 
#endif