Function.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURFUNCTION_H
#define MINOTAURFUNCTION_H
 
#include "Types.h"
#include "LinearFunction.h"
#include "NonlinearFunction.h"
#include "QuadraticFunction.h"
 
namespace Minotaur {
 
  struct LTHessStor;
 
  class Function {
  public:
 
    Function();
 
    Function(LinearFunctionPtr lf);
 
    Function(LinearFunctionPtr lf, QuadraticFunctionPtr qf);
 
    Function(LinearFunctionPtr lf, NonlinearFunctionPtr nlf);
 
    Function(LinearFunctionPtr lf, QuadraticFunctionPtr qf,
             NonlinearFunctionPtr nlf);
 
    Function(NonlinearFunctionPtr nlf);
 
    virtual ~Function();
 
    virtual FunctionPtr cloneWithVars(VariableConstIterator vbeg, int *err)
      const;
 
    virtual FunctionPtr cloneWithVarsPermute(VariableConstIterator vbeg, UIntVector variableaddress, int *err)
      const;
 
    virtual double eval(const DoubleVector &x, int *error) const;
 
    virtual double eval(const double *x, int *error) const;
 
    virtual void prepJac();
 
    virtual void evalGradient(const double *x, double *grad_f, int *error) 
      const;
 
    virtual void fillJac(const double *x, double *values, int *error);
    virtual UInt getNumNzInHess();
 
    virtual bool hasVar(VariablePtr var) const;
 
    virtual FunctionType getType();
 
    bool isLinearIn(ConstVariablePtr v);
    virtual FunctionType getVarFunType(ConstVariablePtr v);
 
    virtual LinearFunctionPtr getLinearFunction() const;
 
    virtual QuadraticFunctionPtr getQuadraticFunction() const;
 
    virtual NonlinearFunctionPtr getNonlinearFunction() const;
 
    VarSetConstIterator varsBegin();
 
    VarSetConstIterator varsEnd();
 
    virtual UInt getNumVars() const;
 
    virtual void evalHessian(const double mult, const double *x, 
                             const size_t *offset, double *values , int *error);
    virtual void evalHessian(double mult, const double *x, 
                             const LTHessStor *stor, double *values , int *error);
 
 
    virtual void fillHessOffset(size_t *offset, size_t &pos, 
                                std::set<ConstVariablePair, CompareVariablePair> & v_pairs);
 
    virtual void  fillHessStor(LTHessStor *stor);
    virtual void  finalHessStor(const LTHessStor *stor);
 
    virtual void changeLf(LinearFunctionPtr lf);
 
    virtual void changeNlf(NonlinearFunctionPtr nlf);
 
    virtual void subst(VariablePtr out, VariablePtr in, double rat);
 
    virtual void operator*=(const double c);
 
    QuadraticFunctionPtr removeQuadratic();
 
    LinearFunctionPtr removeLinear();
 
    NonlinearFunctionPtr removeNonlinear();
 
    void add(ConstLinearFunctionPtr lPtr);
 
    void removeVar(VariablePtr v, double val);
    double getFixVarOffset(VariablePtr v, double val);
 
    friend std::ostream &operator<<(std::ostream &out, const Function &f);
 
    virtual void write(std::ostream &out) const;
 
  protected:
    FunctionType type_;
 
    VariableSet vars_;
 
    private:
 
    LinearFunctionPtr lf_;
 
    NonlinearFunctionPtr nlf_;
 
    QuadraticFunctionPtr qf_;
 
    void collectVars_();
 
    //
    //void createHessMap_();
  };
 
}
#endif