Problem.h

Go to the documentation of this file.

//
//    Minotaur -- It's only 1/2 bull
//
//    (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURPROBLEM_H
#define MINOTAURPROBLEM_H
 
#include <ios>
#include "Types.h"
#include "Constraint.h"
#include "Engine.h"
#include "HessianOfLag.h"
#include "Jacobian.h"
#include "Objective.h"
#include "ProblemSize.h"
#include "SOS.h"
#include "Types.h"
#include "Variable.h"
#include <limits>
namespace Minotaur
{
 
  struct ConstraintStats
  {
    int nvars = 0;
    int nterms = 0;
    int nsqterm = 0;
    int nbilterm = 0;
    int nposcoefone = 0;
    int nnegcoefone = 0;
    int nposcoef = 0;
    int nnegcoef = 0;
    int nposcont = 0;
    int nnegcont = 0;
    int nposbin = 0;
    int nnegbin = 0;
    int nposint = 0;
    int nnegint = 0;
    int eqwt = 0;
    double wt1 = 0.0;
    double wt2 = 0.0;
    double sumnegwt = 0.0;
    int con = 0;
  };
 
class Problem
{
public:
  Problem(EnvPtr env);
 
  virtual ~Problem();
 
  virtual void addToCons(ConstraintPtr cons, double c);
 
  virtual void addToObj(LinearFunctionPtr lf);
 
  virtual void addToObj(double cb);
 
 
  virtual void calculateSize(bool shouldRedo = false);
 
  virtual void changeBoundByInd(UInt ind, BoundType lu, double new_val);
 
  virtual void changeBoundByInd(UInt ind, double new_lb, double new_ub);
 
  virtual void changeBound(VariablePtr var, BoundType lu, double new_val);
 
  virtual void changeBound(VariablePtr var, double new_lb, double new_ub);
 
  virtual void changeBound(ConstraintPtr con, BoundType lu, double new_val);
 
  virtual void changeBound(ConstraintPtr con, double new_lb, double new_ub);
 
  virtual void changeConstraint(ConstraintPtr con, LinearFunctionPtr lf,
                                double lb, double ub);
 
  virtual void changeConstraint(ConstraintPtr con, NonlinearFunctionPtr nlf);
 
  virtual void changeObj(FunctionPtr f, double cb);
 
  virtual int checkConVars() const;
 
  // Classification of Constraints
  virtual void classifyCon();
 
  ProblemPtr clone(EnvPtr env) const;
 
  ProblemPtr shuffle(bool varshuff, bool conshuff, EnvPtr env);
 
  void cg2qf();
 
  virtual ConstraintConstIterator consBegin() const
  {
    return cons_.begin();
  }
 
  virtual ConstraintConstIterator consEnd() const
  {
    return cons_.end();
  }
 
  virtual void delMarkedCons();
 
  virtual void delMarkedVars(bool keep = false);
 
  virtual ProblemType findType();
 
  virtual ConstraintPtr getConstraint(UInt index) const;
 
  virtual DoubleVector* getDebugSol() const;
 
  virtual HessianOfLagPtr getHessian() const;
 
  virtual JacobianPtr getJacobian() const;
 
  virtual UInt getNumCons() const
  {
    return cons_.size();
  }
 
  virtual UInt getNumDCons() const
  {
    return numDCons_;
  }
 
  virtual UInt getNumDVars() const
  {
    return numDVars_;
  }
 
  virtual UInt getNumHessNnzs() const;
 
  virtual UInt getNumJacNnzs() const;
 
  UInt getNumLinCons();
 
  UInt getNumSOS1();
 
  UInt getNumSOS2();
 
  virtual UInt getNumVars() const
  {
    return vars_.size();
  }
 
  virtual ObjectivePtr getObjective() const;
 
  double getObjValue(const double* x, int* err) const;
 
  ConstProblemSizePtr getSize() const;
 
  double getSizeEstimate();
 
  virtual VariablePtr getVariable(UInt index) const;
 
  virtual bool hasNativeDer() const;
 
  virtual bool isDebugSolFeas(double atol, double rtol);
 
  virtual bool isLinear();
 
  virtual bool isMarkedDel(ConstConstraintPtr con);
 
  virtual bool isMarkedDel(ConstVariablePtr var);
 
  virtual bool isQP();
 
  virtual bool isQuadratic();
 
  virtual void markDelete(ConstraintPtr con);
 
  // Helper function for common quadratic checks
  inline bool checkQuadCond(const ConstraintStats& stats)
  {
    return stats.nsqterm == stats.nterms + stats.nvars;
  }
 
  // Helper function for coefficient checks
  inline bool checkCoeffCond(const ConstraintStats& stats,
                                        bool positive)
  {
    if (positive) {
      return stats.nposcoefone == stats.nterms + stats.nvars ||
             (stats.nposcoef == stats.nterms + stats.nvars &&
              stats.eqwt == stats.nterms + stats.nvars);
    } else {
      return stats.nnegcoefone == stats.nterms + stats.nvars ||
             (stats.nnegcoef == stats.nterms + stats.nvars &&
              stats.eqwt == stats.nterms + stats.nvars);
    }
  }
 
  virtual void markDelete(VariablePtr var);
 
  virtual void negateObj();
 
  virtual VariablePtr newBinaryVariable();
 
  virtual VariablePtr newBinaryVariable(std::string name);
 
  virtual ConstraintPtr newConstraint(FunctionPtr f, double lb, double ub);
 
  virtual ConstraintPtr newConstraint(FunctionPtr f, double lb, double ub,
                                      std::string name);
 
  virtual ObjectivePtr newObjective(FunctionPtr f, double cb,
                                    ObjectiveType otyp);
 
  virtual ObjectivePtr newObjective(double cb, ObjectiveType otyp);
 
  virtual ObjectivePtr newObjective(FunctionPtr f, double cb,
                                    ObjectiveType otyp, std::string name);
 
  virtual SOSPtr newSOS(int n, SOSType type, const double* weights,
                        const VarVector& vars, int priority,
                        std::string name);
 
  virtual SOSPtr newSOS(int n, SOSType type, const double* weights,
                        const VarVector& vars, int priority);
 
  virtual VariablePtr newVariable(VarSrcType stype = VarOrig);
 
  virtual VariablePtr newVariable(double lb, double ub, VariableType vtype,
                                  VarSrcType = VarOrig);
 
  virtual VariablePtr newVariable(double lb, double ub, VariableType vtype,
                                  std::string name, VarSrcType = VarOrig);
 
  virtual void newVariables(VariableConstIterator v_begin,
                            VariableConstIterator v_end,
                            VarSrcType stype = VarOrig);
 
  virtual void prepareForSolve();
 
  virtual void objToCons();
 
  virtual void removeObjective();
 
  virtual QuadraticFunctionPtr removeQuadFromObj();
 
  virtual NonlinearFunctionPtr removeNonlinFromObj();
 
  virtual void resetDer();
 
  virtual void resConTypCnt();
 
  virtual void reverseSense(ConstraintPtr cons);
 
  virtual void setDebugSol(const DoubleVector& x);
 
  virtual void setEngine(Engine* engine);
 
  virtual void setHessian(HessianOfLagPtr hessian);
 
  virtual void setInitialPoint(const double* x);
 
  virtual void setInitialPoint(const double* x, size_t k);
 
  virtual void setInitVal(VariablePtr v, double val);
  virtual void setInitValByInd(UInt ind, double val);
 
  virtual void setJacobian(JacobianPtr jacobian);
 
  void setNativeDer();
 
  virtual void setVarType(VariablePtr var, VariableType type);
 
  virtual SOSConstIterator sos1Begin() const
  {
    return sos1_.begin();
  };
  virtual SOSConstIterator sos1End() const
  {
    return sos1_.end();
  };
  virtual SOSConstIterator sos2Begin() const
  {
    return sos2_.begin();
  };
  virtual SOSConstIterator sos2End() const
  {
    return sos2_.end();
  };
 
  virtual void subst(VariablePtr out, VariablePtr in, double rat = 1.0);
 
  virtual void unsetEngine();
 
  virtual VariableConstIterator varsBegin() const
  {
    return vars_.begin();
  }
 
  virtual VariableConstIterator varsEnd() const
  {
    return vars_.end();
  }
 
  virtual void write(std::ostream& out, std::streamsize out_p = 6) const;
 
  virtual void writeSize(std::ostream& out) const;
 
  //Print statistics in log_level 2 
  void statistics(std::ostream& out) const;
 
  const double INFTY = std::numeric_limits<double>::infinity();
 
  protected:
    //To check type of constraint
    bool isAggregation_(ConstraintPtr c);
    bool isPrecedence_(ConstraintPtr c, const ConstraintStats &stats);
    bool isVariableBound_(ConstraintPtr c, const ConstraintStats &stats);
    bool isSetPartitioning_(ConstraintPtr c, const ConstraintStats &stats);
    bool isSetPacking_(ConstraintPtr c, const ConstraintStats &stats);
    bool isSetCovering_(ConstraintPtr c, const ConstraintStats &stats);
    bool isCardinality_(ConstraintPtr c, const ConstraintStats &stats);
    bool isInvariantKnapsack_(ConstraintPtr c, const ConstraintStats &stats);
    bool isEquationKnapsack_(ConstraintPtr c, const ConstraintStats &stats);
    bool isBinPacking_(ConstraintPtr c, const ConstraintStats &stats);
    bool isKnapsack_(ConstraintPtr c, const ConstraintStats &stats);
    bool isIntegerKnapsack_(ConstraintPtr c, const ConstraintStats &stats);
    bool isMixedBinary_(ConstraintPtr c, const ConstraintStats &stats);
    bool isNoSpecificStructure_(ConstraintPtr c);
    bool isDiagonalQuadratic_(ConstraintPtr c, const ConstraintStats& stats);
    bool isSimpleBall_(ConstraintPtr c, const ConstraintStats& stats);
    bool isEllipsoid_(ConstraintPtr c, const ConstraintStats& stats);
    bool isComplementEllipsoid_(ConstraintPtr c, const ConstraintStats& stats);
    bool isComplementSimpleBall_(ConstraintPtr c, const ConstraintStats& stats);
    bool isSocSimple_(ConstraintPtr c, const ConstraintStats& stats);
    bool isPureBilinear_(ConstraintPtr c, const ConstraintStats& stats);
    bool isOtherQuadType_(ConstraintPtr c, const ConstraintStats& stats);
    
    //Print Count table for constraint size
    void printConstraintStatistics_();
 
    //Print Count table for Quadratic constraint size
    void printConstraintStatisticsQuad_();
 
  // function for lock number
  void lockNum_();
 
  ConstraintVector cons_;
 
  bool consModed_;
 
  DoubleVector* debugSol_;
 
  Engine* engine_;
 
  HessianOfLagPtr hessian_;
 
  JacobianPtr jacobian_;
 
  LoggerPtr logger_;
 
  static const std::string me_;
 
  bool nativeDer_;
 
  UInt nextCId_;
 
  int nextSId_;
 
  UInt nextVId_;
 
  UInt numDCons_;
 
  UInt numDVars_;
 
  ObjectivePtr obj_;
 
  ProblemSizePtr size_;
 
  SOSVector sos1_;
 
  SOSVector sos2_;
 
  VarVector vars_;
 
  VarVector varsRem_;
 
  bool varsModed_;
 
  virtual void countConsTypes_();
 
  virtual void countObjTypes_();
 
  virtual void countVarTypes_();
 
  virtual void findVarFunTypes_();
 
  bool isPolyp_();
 
  void setIndex_(VariablePtr v, UInt i);
};
}  // namespace Minotaur
#endif