QuadraticFunction.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURQUADRATICFUNCTION_H
#define MINOTAURQUADRATICFUNCTION_H
 
#include "Types.h"
 
 
#include "VarBoundMod.h"
 
 
 
namespace Minotaur {
  class LinearFunction;
  struct LTHessStor;
  class QuadraticFunction;
  class PolynomialFunction;
  class Variable;
  typedef QuadraticFunction* QuadraticFunctionPtr;
  typedef const QuadraticFunction* ConstQuadraticFunctionPtr;
  typedef PolynomialFunction* PolyFunPtr;
  typedef const LinearFunction* ConstLinearFunctionPtr;
  typedef LinearFunction* LinearFunctionPtr;
  typedef std::vector<QuadraticFunctionPtr> QfVector;
  //class EigenVector;
  //typedef std::pair<double, EigenVectorPtr> EigenPair;
 
  class QuadraticFunction {
    public:
      QuadraticFunction();
 
      QuadraticFunction(UInt nz, double *vals, UInt *irow, UInt *jcol,
                        VariableConstIterator vbeg );
 
      QuadraticFunction(double* vals, VariableConstIterator vbeg,
                        VariableConstIterator vend);
 
      ~QuadraticFunction();
 
      QuadraticFunctionPtr clone() const;
 
      QuadraticFunctionPtr cloneWithVars(VariableConstIterator vbeg) const;
 
      void addTerm(VariablePair vp, const double weight); 
 
      void addTerm(ConstVariablePtr v1, ConstVariablePtr v2, double weight);
      
      double getFixVarOffset(VariablePtr v, double val);
 
      void incTerm(ConstVariablePair vp, const double weight);
 
      void incTerm(ConstVariablePtr v1, ConstVariablePtr v2, const double weight);
 
      
      void multiply(double c);
 
      void removeVar(VariablePtr v, double val, LinearFunctionPtr lf);
 
      void subst(VariablePtr out, VariablePtr in, double rat);
 
      //friend QuadraticFunctionPtr operator + (const QuadraticFunction q1, 
      //    const QuadraticFunction q2);
      QuadraticFunctionPtr copyAdd(ConstQuadraticFunctionPtr q2) const ;  
 
      QuadraticFunctionPtr copyMinus(ConstQuadraticFunctionPtr  q2) const;
 
      QuadraticFunctionPtr copyMult(double c) const;
 
      PolyFunPtr copyMult(LinearFunctionPtr l1) const;
 
      PolyFunPtr copyMult(ConstQuadraticFunctionPtr q2) const;
 
 
      void add(ConstQuadraticFunctionPtr q2);
 
 
      VarCountConstMap * getVarMap() const;
 
      VariablePairGroupConstIterator begin() const { return(terms_.begin()); }
 
      VariablePairGroupConstIterator end() const { return(terms_.end()); }
 
      double getWeight(ConstVariablePair & vp) ;
 
      double getWeight(ConstVariablePtr v1, ConstVariablePtr v2) ;
 
      int getFreq(ConstVariablePtr v1);
 
      bool hasVar(ConstVariablePtr v) const;
 
      double eval(const std::vector<double> &x) const;
 
      double eval(const double *x) const;
 
      void computeBounds(double *l, double *u);
 
      // /**
      //  * Changing bounds of variables based on bounds of constraints
      //  */
      // void varBoundMods(double lb, double ub, VarBoundModVector &mods,
      //                     SolveStatus *status);
 
 
       // /**
      //  * getting b for variable v (in ax^2 +bx)
      //  */
 
      void bndsquadterms(double *l, double *u, VariablePtr v);
 
 
      // /**
      //  * getting b for variable v (in ax^2 +bx), excluding terms containing v2
      //  */ 
 
      void bndsquadterms_2(double *l, double *u, VariablePtr v, VariablePtr v2);
 
 
      void evalGradient(const double *x, double *grad_f); 
 
      void evalGradient(const std::vector<double> &x,
                        std::vector<double> &grad_f); 
      
      void evalHessian(const double mult, const double *x, 
                       const LTHessStor *stor, double *values , int *error);
      
      Convexity isConvex();
 
      QfVector findSubgraphs();
      
      void prepJac(VarSetConstIter vbeg, VarSetConstIter vend);
 
      void prepHess();
 
      void fillHessStor(LTHessStor *hess);
 
      void fillJac(const double *x, double *values, int *error);
      void finalHessStor(const LTHessStor *hess);
 
      UInt getNumTerms() const;
      
      UInt getNumBilTerms() const;
 
      UInt getNumSqTerms() const;
 
      UInt getNumVars() const;
 
      void getVars(VariableSet *vars);
 
      bool isZero() const { return (getNumTerms() == 0); }
 
      NonlinearFunctionPtr getPersp(VariablePtr z, double eps,
                                      VariableGroup nNonzeroVar, double intTol);
 
      VarIntMapConstIterator varsBegin() const;
 
      VarIntMapConstIterator varsEnd() const;
 
      void write(std::ostream &s) const;
 
    private:
      const double etol_;
      
      double *hCoeffs_;
 
      UInt *hFirst_;
      UInt *hOff_;
 
      UInt *hSecond_;
 
      UIntVector hStarts_;
 
      UIntVector jacOff_;
      UIntVector jacInd_;
 
      VariablePairGroup terms_;
 
      VarIntMap varFreq_;
 
      Convexity convex_;
 
      void sortLT_(UInt n, UInt *f, UInt *s, double *c);
  };
 
}
#endif