NonlinearFunction.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2009 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURNONLINEARFUNCTION_H
#define MINOTAURNONLINEARFUNCTION_H
 
#include "Types.h"
 
namespace Minotaur {
 
  struct LTHessStor;
  class NonlinearFunction;
  class VarBoundMod;
  typedef NonlinearFunction *NonlinearFunctionPtr;
  typedef VarBoundMod *VarBoundModPtr;
  typedef std::vector<VarBoundModPtr> VarBoundModVector;
  typedef VarBoundModVector::iterator VarBoundModIter;
 
  class NonlinearFunction {
 
  public:
    NonlinearFunction();
 
    virtual ~NonlinearFunction();
 
    virtual void addConst(const double d, int &err);
 
    virtual void sqrRoot(int &err);
 
    virtual NonlinearFunctionPtr cloneWithVars(VariableConstIterator vbeg,
                                               int *err) const = 0;
 
    virtual void computeBounds(double *lb, double *ub, int *error);
 
    virtual double eval(const double *x, int *error) = 0;
 
    virtual void evalGradient(const double *x, double *grad_f,
                              int *error) = 0;
 
    virtual void evalHessian(const double mult, const double *x,
                             const LTHessStor *stor, double *values,
                             int *error) = 0;
 
    virtual void fillHessStor(LTHessStor *stor) = 0;
 
    virtual void fillJac(const double *x, double *values, int *error) = 0;
 
    virtual void finalHessStor(const LTHessStor *stor) = 0;
 
    virtual std::string getNlString(int *err);
 
    virtual double getFixVarOffset(VariablePtr /* v */, double /* val */)
    {
      assert(!"implment me!");
      return 0;
    };
 
    virtual FunctionType getType() const;
 
    virtual void getVars(VariableSet *vars) = 0;
 
    virtual bool hasVar(ConstVariablePtr v) const;
 
    virtual bool isSumOfSquares() const { return true; }
 
    virtual void multiply(double c) = 0;
 
    virtual size_t numVars() { return vars_.size(); };
 
    virtual void prepJac(VarSetConstIter vbeg, VarSetConstIter vend) = 0;
 
    virtual void removeVar(VariablePtr /* v */, double /* val */)
    {
      assert(!"implement me!");
    };
 
    virtual void subst(VariablePtr /* out */, VariablePtr /* in */,
                       double /* rat */)
    {
      assert(!"implement me!");
    };
 
    virtual NonlinearFunctionPtr getPersp(VariablePtr z, double eps,
                                          int *err) const;
 
    virtual void varBoundMods(double /* lb */, double /* ub */,
                              VarBoundModVector & /* mods */,
                              SolveStatus * /* status */) {};
 
    virtual VariableSet::iterator varsBegin() { return vars_.begin(); };
 
    virtual VariableSet::iterator varsEnd() { return vars_.end(); };
 
    virtual void write(std::ostream &out) const;
 
  protected:
    VariableSet vars_;
  };
 
  typedef NonlinearFunction *NonlinearFunctionPtr;
  typedef const NonlinearFunction *ConstNonlinearFunctionPtr;
 
}  //namespace Minotaur
#endif