PolynomialFunction.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURPOLYNOMIALFUNCTION_H
#define MINOTAURPOLYNOMIALFUNCTION_H
 
#include "NonlinearFunction.h"
 
namespace Minotaur {
 
  class CGraph;
  class CNode;
  class LinearFunction;
  class MonomialFunction;
  class QuadraticFunction;
  typedef CGraph* CGraphPtr;
  typedef LinearFunction* LinearFunctionPtr;
  typedef MonomialFunction* MonomialFunPtr;
  typedef QuadraticFunction* QuadraticFunctionPtr;
  typedef const LinearFunction* ConstLinearFunctionPtr;
  typedef const MonomialFunction* ConstMonomialFunPtr;
  typedef const QuadraticFunction* ConstQuadraticFunctionPtr;
  typedef std::vector<MonomialFunPtr> MonomialVector;
  typedef MonomialVector::iterator MonomialIter;
  typedef MonomialVector::const_iterator MonomialConstIter;
 
 
  class PolynomialFunction;
  typedef PolynomialFunction* PolyFunPtr;
  typedef const PolynomialFunction* ConstPolyFunPtr;  
 
  class MonomialFunction : public NonlinearFunction {
  public:
    MonomialFunction();
 
    MonomialFunction(double c);
 
    MonomialFunction(double c, ConstVariablePtr v, UInt p);
 
    ~MonomialFunction();
 
    MonomialFunPtr clone() const;
 
    NonlinearFunctionPtr cloneWithVars(VariableConstIterator vbeg, 
                                       int *err) const;
 
    // Evaluate.
    double eval(const double *x, int *error);
 
    // Evaluate.
    double eval(const DoubleVector &x, int *error);
 
    // Gradient.
    void evalGradient(const double *x, double *grad_f, int *error);
 
    void evalHessian(const double , const double *, 
                     const LTHessStor *, double *, 
                     int *) 
    {assert(!"can't fill hessian in a monomial function.");};
 
    CNode* fillCG(CGraphPtr cg);
 
    void fillJac(const double *, double *, int *) 
    {assert(!"can't fill jacobian in a monomial function.");};
 
    void  fillHessStor(LTHessStor *)
    {assert(!"can't fill hessian in a monomial function.");};
 
    void  finalHessStor(const LTHessStor *) 
    {assert(!"can't fill hessian in a monomial function.");};
 
    double getCoeff() const;
 
    int getDegree() const;
 
    const VarIntMap* getTerms() const;
 
    void getVars(VariableSet *) {};
 
    void multiply(double coeff, ConstVariablePtr v, int p);
 
    void multiply(ConstMonomialFunPtr m2);
 
    void multiply(double c);
 
    void prepJac(VarSetConstIter, VarSetConstIter)
    {assert(!"can't fill jacobian in a monomial function.");};
 
    VarIntMapConstIterator termsBegin();
 
    VarIntMapConstIterator termsEnd();
 
    void toPower(int k);
 
    void write(std::ostream &out) const;
 
    void operator*=(double c);
 
    void operator*=(ConstMonomialFunPtr m2);
 
  private:
    double coeff_;
 
    int deg_;
 
    const double eTol_;
 
    VarIntMap terms_;
  };
 
  // --------------------------------------------------------------------------
  // --------------------------------------------------------------------------
 
  class PolynomialFunction : public NonlinearFunction {
  public:
    PolynomialFunction();
 
    PolynomialFunction(CGraphPtr cg);
 
    ~PolynomialFunction();
 
    PolyFunPtr clone() const;
 
    void add(ConstMonomialFunPtr m);
 
    // base class function.
    NonlinearFunctionPtr cloneWithVars(VariableConstIterator vbeg, 
                                       int *err) const;
 
    void createCG();
 
    // base class function.
    double eval(const double *x, int *error);
 
    // base class function.
    void evalGradient(const double *x, double *grad_f, int *error);
 
    // base class function.
    void evalHessian(const double mult, const double *x, 
                     const LTHessStor *stor, double *values, 
                     int *error);
 
    // base class function.
    void  fillHessStor(LTHessStor *stor);
 
    // base class function.
    void fillJac(const double *x, double *values, int *error);
 
    // base class function.
    void  finalHessStor(const LTHessStor *stor);
 
    // base class function.
    void getVars(VariableSet *);
 
    double getConstant();
 
    FunctionType getType() const;
 
    bool isEmpty() const;
 
    void multiply(ConstLinearFunctionPtr lf, double c);
 
    void multiply(double c);
 
    // base class function.
    void prepJac(VarSetConstIter vb, VarSetConstIter ve);
 
    void recCG_(const CNode* cnode, double *c, MonomialVector *terms);
    void recCGMult_(MonomialVector *t1, MonomialVector *t2,
                    double c1, double c2,
                    MonomialVector *terms, double *c);
    double removeConstant();
 
    void removeLinear(LinearFunctionPtr lf);
 
    void removeQuadratic(QuadraticFunctionPtr qf);
 
    MonomialConstIter termsBegin();
 
    MonomialConstIter termsEnd();
 
    void write(std::ostream &out) const;
 
    //void operator+=(ConstMonomialFunPtr m);
    //void add(ConstMonomialFunPtr m);  
    
    //void operator+=(double c);
    void add(const double c);
 
    //void operator+=(ConstLinearFunctionPtr lf);
    void add(ConstLinearFunctionPtr lf);
 
    //void operator+=(ConstQuadraticFunctionPtr qf);
    void  add(ConstQuadraticFunctionPtr qf);
 
    //void operator+=(ConstPolyFunPtr p);
    void add(ConstPolyFunPtr p);
 
    //void operator*=(ConstQuadraticFunctionPtr qf);
    void multiply(ConstQuadraticFunctionPtr qf);
 
    //void operator*=(ConstPolyFunPtr p2);
    void multiply(ConstPolyFunPtr p2);
 
    //friend PolyFunPtr operator + (ConstPolyFunPtr p1, ConstPolyFunPtr p2);
    PolyFunPtr copyAdd(ConstPolyFunPtr p2) const;
 
    PolyFunPtr copyMinus(ConstPolyFunPtr p2);
 
    PolyFunPtr copyMult(double c);
 
    PolyFunPtr copyMult(ConstLinearFunctionPtr l2) const;
 
    PolyFunPtr copyMult(ConstQuadraticFunctionPtr q2) const;
 
    PolyFunPtr copyMult(ConstPolyFunPtr p2) const;
 
  protected:
    double cb_;
 
    CGraphPtr cg_;
 
    const double eTol_;
 
    MonomialVector terms_;
 
    void clear_();
  };
 
}
#endif