CxUnivarHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURCXUNIVARHANDLER_H
#define MINOTAURCXUNIVARHANDLER_H
 
#include "Handler.h"
#include "Types.h"
 
namespace Minotaur {
 
  class Engine;
  class Function;
  class LinearFunction;
  class Objective;
  class Problem;
  typedef LinearFunction* LinearFunctionPtr;
  typedef Objective* ObjectivePtr;
 
 
  class CxUnivarConstraintData {
 
  protected:
 
    double eTol_;
 
    double vTol_;
 
    ConstraintPtr con_;
 
    ConstVariablePtr iv_;
 
    // Points to the relaxation version of the input variable
    // Updated only after relaxInit is called
    VariablePtr riv_;
 
    ConstVariablePtr ov_;
 
    // Points to the relaxation version of the output variable
    // Updated only after relaxInit is called
    VariablePtr rov_;
 
    char sense_;
 
    ConstraintPtr secCon_; 
 
    ConstraintVector linCons_;
 
  public:
 
    void initRelax(RelaxationPtr rel, DoubleVector& tmpX, DoubleVector& grad);
 
    void updateRelax(RelaxationPtr rel, DoubleVector& tmpX, DoubleVector& grad,
                     ModVector &mods);
 
    bool isFeasible(const double* x);
 
    double getViol(const std::vector< double > & x);
 
    // Creates and adds the secant inequality defined by current constraint to
    // the relaxation
    // Returns the constraint that was added, which may be null if it was not
    // possible to add a constraint (e.g., due to an infinite bound)
    void addSecant(RelaxationPtr rel, ConstVariablePtr iv,
                   ConstVariablePtr ov, FunctionPtr fn, DoubleVector& tmpX,
                   bool init, ModVector &mods);
 
    // Creates and adds linearization inequalities to approximate the lower
    // envelope of the convex function
    // Returns a vector of constraints that were added
    void addLin(RelaxationPtr rel, ConstVariablePtr iv,
                ConstVariablePtr ov, FunctionPtr fn,
                DoubleVector& tmpX, DoubleVector& grad, bool init,
                ModVector &mods);
 
    ConstraintPtr getOriginalCon() const { return con_; }
    ConstraintPtr getSecantCon() const { return secCon_; }
 
    ConstVariablePtr getROutVar() const { return rov_; } ;
 
    ConstVariablePtr getRInputVar() const { return riv_; } ;
 
    //ConstraintVector & getLinCons
    ConstraintIterator linConsBegin()  { return linCons_.begin(); }
    ConstraintIterator linConsEnd() { return linCons_.end(); }
 
 
    char getSense() { return sense_; } ;
 
    CxUnivarConstraintData(double eTol, double vTol, ConstraintPtr newcon, ConstVariablePtr ovar,
                           ConstVariablePtr ivar, char sense);
 
    ~CxUnivarConstraintData() {};
 
 
  };
 
  typedef CxUnivarConstraintData* CxUnivarConstraintDataPtr;
  typedef std::vector<CxUnivarConstraintDataPtr> CxUnivarConstraintDataVector;
  typedef CxUnivarConstraintDataVector::iterator CxUnivarConstraintIterator;
 
 
  class CxUnivarHandler : public Handler {
 
 
  protected:
 
    double eTol_;
 
    double vTol_;
 
    ProblemPtr problem_;
 
    LoggerPtr logger_;
 
    static const std::string me_;
 
    CxUnivarConstraintDataVector cons_data_;
 
    DoubleVector tmpX_;
 
    DoubleVector grad_;
 
  public:
    CxUnivarHandler(EnvPtr env, ProblemPtr problem);
 
    ~CxUnivarHandler();
 
    void addConstraint(ConstraintPtr newcon, ConstVariablePtr ivar,
                       ConstVariablePtr ovar, char sense = 'E'); 
 
    // base class method.
    void addConstraint(ConstraintPtr ) { assert(0); };
 
    void relaxInitFull(RelaxationPtr, SolutionPool *, bool*) {};
 
    void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool* is_inf);  
 
    bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation, 
                    bool &should_prune, double &inf_meas);
 
    void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, 
                  CutManager *cutman, SolutionPoolPtr s_pool, ModVector &p_mods,
                  ModVector &r_mods, bool *sol_found,
                  SeparationStatus *status);
 
 
 
    virtual void relaxNodeFull(NodePtr /* node */, RelaxationPtr /* rel */,
                               bool* /* should_prune */) {} ; 
 
    virtual void relaxNodeInc(NodePtr  node, RelaxationPtr rel,
                              bool* isInfeasible);
 
    // base class method
    virtual void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x,
                                        ModVector &mods, BrVarCandSet &cands,
                                        BrCandVector &gencands, bool & is_inf);
 
    // Implement Handler::getBrMod().
    virtual ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x, 
                                     RelaxationPtr rel, BranchDirection dir);
 
    // Implement Handler::getBranches().
    virtual Branches getBranches(BrCandPtr cand, DoubleVector & x,
                                 RelaxationPtr rel, SolutionPoolPtr s_pool);
 
    // presolve.
    virtual SolveStatus presolve(PreModQ *pre_mods, bool *changed,
                                 Solution **sol);
 
    // Implement Handler::presolveNode().
    virtual bool presolveNode(RelaxationPtr p, NodePtr node,
                              SolutionPoolPtr s_pool, ModVector &p_mods,
                              ModVector &r_mods);
 
 
    // Write name
    virtual std::string getName() const;
 
  private:
    // Helper functions
    BranchPtr doBranch_(BranchDirection UpOrDown, ConstVariablePtr v,
                        double bvalue);
 
 
 
  };
 
  typedef CxUnivarConstraintData* CxUnivarConstraintDataPtr;
 
  typedef const CxUnivarConstraintData* CxUnivarConstConstraintDataPtr;
 
  typedef CxUnivarHandler* CxUnivarHandlerPtr;
 
  typedef const CxUnivarHandler* CxUnivarConstHandlerPtr;
}
#endif