SliceFacade.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 SLICE_FACADE_GUARD
#define SLICE_FACADE_GUARD
 
#include "SplitStrategy.h"
#include "Ideal.h"
#include "Facade.h"
#include "SliceParams.h"
#include "TermConsumer.h"
#include "CoefTermConsumer.h"
#include "CommonParamsHelper.h"
 
#include <vector>
#include <cstdio>
#include <string>
 
class BigIdeal;
class BigTermConsumer;
class CoefBigTermConsumer;
class SliceStrategy;
class IOHandler;
class DataType;
 
class SliceFacade : public Facade {
 public:
  SliceFacade(const SliceParams& params, const DataType& output);
  SliceFacade(const SliceParams& params,
              const BigIdeal& ideal,
              BigTermConsumer& consumer);
  SliceFacade(const SliceParams& params,
              const BigIdeal& ideal,
              CoefBigTermConsumer& consumer);
 
  ~SliceFacade();
 
  void computeMultigradedHilbertSeries();
 
  void computeUnivariateHilbertSeries();
 
  void computeIrreducibleDecomposition(bool encode);
 
  mpz_class computeDimension(bool codimension = false);
 
  void computeDimension(mpz_class& dimension);
 
  void computePrimaryDecomposition();
 
  void computeMaximalStaircaseMonomials();
 
  void computeMaximalStandardMonomials();
 
  void computeAlexanderDual(const vector<mpz_class>& point);
 
  void computeAlexanderDual();
 
  void computeAssociatedPrimes();
 
  bool solveStandardProgram
    (const vector<mpz_class>& grading,
     mpz_class& value,
     bool reportAllSolutions);
 
  bool solveIrreducibleDecompositionProgram
    (const vector<mpz_class>& grading,
     mpz_class& optimalValue,
     bool reportAllSolutions);
 
 private:
  void produceEncodedIrrDecom(TermConsumer& consumer);
 
  bool solveProgram(const vector<mpz_class>& grading,
                    mpz_class& optimalValue,
                    bool reportAllSolutions);
 
  bool isFirstComputation() const;
 
  void takeRadical();
 
  void getLcmOfIdeal(vector<mpz_class>& lcm);
 
  void runSliceAlgorithmWithOptions(SliceStrategy& strategy);
 
  SliceParams _params;
  CommonParamsHelper _common;
  auto_ptr<SplitStrategy> _split;
};
 
#endif