MaxInfBrancher.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURMAXINFBRANCHER_H
#define MINOTAURMAXINFBRANCHER_H
 
#include "Brancher.h"
 
namespace Minotaur {
 
class Engine;
class Timer;
typedef Engine* EnginePtr;
 
struct MaxInfBrStats {
    UInt bndChange;  
    UInt calls;      
    UInt engProbs;   
    UInt iters;      
    UInt strBrCalls; 
    double time;     
};
 
class MaxInfBrancher : public Brancher {
public:
    MaxInfBrancher(EnvPtr env, HandlerVector & handlers);
 
    ~MaxInfBrancher();
 
    // Find a branching candidate. Returns NULL if x does not have any
    // thing to branch on or if no branching candidates are needed. 
    Branches findBranches(RelaxationPtr rel, NodePtr node, 
                          ConstSolutionPtr sol, SolutionPoolPtr s_pool, 
                          BrancherStatus & br_status, ModVector &mods);
 
    // Update pseudo-cost/other information after branching.
    void updateAfterSolve(NodePtr node, ConstSolutionPtr sol);
 
    // Write statistics.
    void writeStats(std::ostream &out) const;
 
    bool getTrustCutoff();
 
    UInt getIterLim();
 
    // base class function.
    std::string getName() const;
 
    UInt getThresh() const;
 
    void initialize(RelaxationPtr rel);
 
    void setTrustCutoff(bool val);
 
    void setEngine(EnginePtr engine);
 
    void setIterLim(UInt k);
 
    void setMaxDepth(UInt k);
 
    void setMinNodeDist(UInt k);
 
    void setThresh(UInt k);
 
    // Print inference score
    void printMaxInferenceScores() const;
 
    // Vector to store up score
    std::vector<double> upScores_;
 
    // Vector to store down score
    std::vector<double> downScores_;
 
    //Infrence score function
    void infScore();
    void statsTable()const;
 
    //Normalize function to calculate score
    double gFunction(double x) const;
 
private:
 
    // inference functions
    void infAggregation_(int idx, int nvars, int nposbin, double wt1, double wt2, ConstraintPtr c);
    void infPrecedence_(int idx, int nvars, int nnegbin, int nposbin, ConstraintPtr c);
    void infVariableBound_(int idx, int nposbin, double wt, double wt1, double wt2, ConstraintPtr c);
    void infSetPartition_(int idx, int nvars, double wt);
    void infSetPack_(int idx, int nvars, double wt);
    void infCardinality_(int idx, int nvars, int nposbin, int nnegcoefone, double wt, ConstraintPtr c);
    void infEquationKnapsack_(int idx, int nvars, double wt, ConstraintPtr c, double sumnegwt);
    void infBinPack_(int idx, int nvars, double wt, ConstraintPtr c, double sumnegwt);
    void infKnapsack_(int idx, int nvars, double wt, ConstraintPtr c, int nposbin, double sumnegwt);
    void infMixed_(VariablePtr v, int idx, double wt, ConstraintPtr c);
    void findCandidates_();
 
    void freeCandidates_(BrCandPtr no_del);
    void getPCScore_(BrCandPtr cand, double *ch_down, double *ch_up, double *score);
    double getScore_(const double & up_score, const double & down_score);
    bool shouldPrune_(const double &chcutoff, const double &change, const EngineStatus & status, bool *is_rel);
    BrCandPtr findBestCandidate_(const double objval, double cutoff, 
                               NodePtr node);
 
    void strongBranch_(BrCandPtr cand, double & obj_up, double & obj_down, EngineStatus & status_up, EngineStatus & status_down);
 
    void updatePCost_(const int &i, const double &new_cost, DoubleVector &cost, UIntVector &count);
 
    void useStrongBranchInfo_(BrCandPtr cand, const double & chcutoff, double & change_up, double & change_down, const EngineStatus & status_up, const EngineStatus & status_down);
 
    void writeScore_(BrCandPtr cand, double score, double change_up, double change_down);
    void writeScores_(std::ostream &out);
 
    EnginePtr engine_;
    const double eTol_;
    UIntVector lastStrBranched_;
    UInt maxDepth_;
    UInt maxIterations_;
    UInt maxStrongCands_;
    UInt minNodeDist_;
    ModVector mods_;
    DoubleVector pseudoDown_;
    DoubleVector pseudoUp_;
    std::vector<BrCandPtr> relCands_;
    UIntVector timesDown_;
    UIntVector timesUp_;
    UInt thresh_;
    bool trustCutoff_;
    std::vector<BrCandPtr> unrelCands_;
    BrancherStatus status_;
    RelaxationPtr rel_;
    DoubleVector x_;
    HandlerVector handlers_;
    Timer *timer_;
    MaxInfBrStats *stats_;
    BrVarCandSet cands_;
    bool init_;
   UIntVector fracCount_;
 
   UIntVector unfixedCount_;
   void updateFracCount_();
   void updateUnfixedCount_();
 
   UIntVector actualTimesUp_;
 
   UIntVector actualTimesDown_;
   std::vector<std::string> variableNames_;
 
 
    const static std::string me_; 
};
 
typedef MaxInfBrancher* MaxInfBrancherPtr;
 
} // namespace Minotaur
 
#endif // MINOTAURMAXINFBRANCHER_H