frobby.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 FROBBY_INCLUSION_GUARD
#define FROBBY_INCLUSION_GUARD
 
// This file contains the public library interface of Frobby.
 
#include "gmp.h"
 
namespace constants {
  extern const char* const version;
}
 
namespace FrobbyImpl {
  class FrobbyIdealHelper;
}
 
namespace Frobby {
  class Ideal {
  public:
    // Construct an ideal with variableCount variables.
    Ideal(size_t variableCount);
    Ideal(const Ideal& ideal);
    ~Ideal();
 
    Ideal& operator=(const Ideal& ideal);
 
    void addExponent(const mpz_t exponent);
    void addExponent(int exponent);
    void addExponent(unsigned int exponent);
 
  private:
    friend class FrobbyImpl::FrobbyIdealHelper;
    FrobbyImpl::FrobbyIdealHelper* _data;
  };
 
  class IdealConsumer {
  public:
    virtual ~IdealConsumer();
 
    virtual void idealBegin(size_t varCount);
 
    virtual void consume(mpz_ptr* exponentVector) = 0;
 
    virtual void idealEnd();
  };
 
  class PolynomialConsumer {
  public:
    virtual ~PolynomialConsumer();
 
    virtual void polynomialBegin(size_t varCount);
 
    virtual void consume(const mpz_t coefficient, mpz_ptr* exponentVector) = 0;
 
    virtual void polynomialEnd();
  };
 
  bool alexanderDual(const Ideal& ideal,
                     const mpz_t* reflectionMonomial,
                     IdealConsumer& consumer);
 
  bool alexanderDual(const Ideal& ideal,
                     const Ideal& reflectionMonomial,
                     IdealConsumer& consumer);
 
  void multigradedHilbertPoincareSeries(const Ideal& ideal,
                                        PolynomialConsumer& consumer);
 
  void univariateHilbertPoincareSeries(const Ideal& ideal,
                                       PolynomialConsumer& consumer);
 
  void irreducibleDecompositionAsIdeals(const Ideal& ideal,
                                        IdealConsumer& consumer);
 
  bool irreducibleDecompositionAsMonomials(const Ideal& ideal,
                                           IdealConsumer& consumer);
 
  void maximalStandardMonomials(const Ideal& ideal,
                                IdealConsumer& consumer);
 
  bool solveStandardMonomialProgram(const Ideal& ideal,
                                    const mpz_t* l,
                                    IdealConsumer& consumer);
 
  void codimension(const Ideal& ideal, mpz_t codim);
 
  void dimension(const Ideal& ideal, mpz_t dim);
 
  void primaryDecomposition(const Ideal& ideal, IdealConsumer& consumer);
 
  void associatedPrimes(const Ideal& ideal, IdealConsumer& consumer);
}
 
#endif