TransSep.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURTRANSSEP_H
#define MINOTAURTRANSSEP_H
 
#include <stack>
 
#include "Constraint.h"
#include "Types.h"
#include "NonlinearFunction.h"
#include "OpCode.h"
#include "CNode.h"
 
namespace Minotaur {
 
  class CGraph;
  class CNode;
  class LinearHandler;
  class Problem;
  typedef CGraph* CGraphPtr;
  typedef std::deque<CNode *> CNodeQ;
 
  class TransSep {
  public:
 
    TransSep();
 
    TransSep(EnvPtr env, ProblemPtr problem);
 
    ~TransSep();
 
    //void checkCons(std::vector<ConstraintPtr> *sepCons);
    void checkCons();
 
    void createCG(std::vector<CGraphPtr> * cg, CNodeQ * dq, int *itnum,
                  CNode **tempN);
 
    bool coeffValue(CNode * n2, double *cv,bool *n, CNode **n1,
                    std::vector<UInt > *idx);
 
    void commonConsCheck(std::vector<double > *constCoeff);
    void depthFS(int j, CNode *n1, std::vector<UInt > * m, int *itnum, CNodeQ *sNodes,
                       std::deque<int > *sOps, std::vector<CNode *> *sVars,
                       std::vector<CNode *> *sConsts);
   
 
    //UInt eqnDirection(ConstraintPtr cptr); 
    bool explore(UInt *j, CNode *n1, std::vector<UInt > * m, int opc, int *itnum, UInt nvar, CNodeQ *sNodes,
                       std::deque<int > *sOps, std::vector<CNode *> *sVars,
                       std::vector<CNode *> *sConsts);
 
    void finalCG(std::vector<CGraphPtr > * cg, 
                 CNode **tempN,std::vector<double > *constCoeff, double *coeff,
                 std::vector<double > *hashVal1,double *x);
 
    void sepDetection();
    //void sepDetection(std::vector<ConstraintPtr> *sepCons);
 
    UInt getNumVars() {return newVars_;}
 
    void markVis(UInt i, int *itnum);
    
    bool ifRepeated(CGraphPtr nlf,LinearFunctionPtr lfnew,
                        CGraphPtr cg,
                       double constCoeff, double coeff, LinearFunctionPtr lf);
    void linearizeObj();
 
    void mergeItrInfo(int mNum, CNodeQ *sNodes, std::deque<int > *sOps,
                            std::vector<CNode *> *sVars,
                            std::vector<CNode *> *sConsts);
 
    int mergeItrNum(int j, int a, std::vector<UInt > * m);
 
           
 
    bool sepPartsSearch(UInt sp, std::vector<CGraphPtr > *nlfnew,
                              std::vector<LinearFunctionPtr > *lfnew,
                              CGraphPtr cg, double constCoeff,
                              LinearFunctionPtr lf, std::vector<UInt > *nsp,
                              double coeff);
 
    bool rootChildren(const CNode * o, std::stack<CNode *> *candNodes,
                      std::stack<int > *candOp,
                      double *coeff, UInt nnode, UInt nvar, double *ub,
                      //double *lb, LinearFunctionPtr lf);
                      LinearFunctionPtr lf);
 
    std::vector<CGraphPtr> sepPartsCGraph(CNodeQ * dq, UInt nnode,
                                          std::vector<double > *constCoeff, double *coeff,
                                          std::vector<double > *hashVal1, double *x);
    bool sepCheck(double coeff, std::stack<CNode *> *candNodes,
                      std::stack<int > *candOp, UInt nnode, UInt nvar,
                      //double *ub, double *lb, LinearFunctionPtr lf);
                      double *ub, LinearFunctionPtr lf);
    
 
    void tempPopulate(CNode *n1, std::stack<CNode *> * tempNodes);
 
 
    void updateVisNodeItr(UInt* j, std::vector<UInt >*m, CNode *n1,
                                int opc, int idx, CNodeQ *sNodes,
                                std::deque<int > *sOps, 
                                std::vector<CNode *> *sVars,
                                std::vector<CNode *> *sConsts);
    void writeProb();
 
  private:
    EnvPtr env_;
 
    LoggerPtr logger_;
 
    // For log:
    static const std::string me_;
 
    // Problem whose constraints are to be checked for separability detection.
    ProblemPtr problem_;
 
    // No. of new variable added to the origina problem after sep detection
    UInt newVars_;
  
    // Separable parts
    std::vector<CNodeQ > sepNodes_;
 
    // Name of the Constraint that are separable
 
    // Opcodes of nodes in separable parts
    std::vector< std::deque< int> > sepOps_;
 
    // Variables in separable parts
    std::vector< std::vector< CNode *> > sepVars_;
 
    // Constant nodes in separable parts
    std::vector< std::vector< CNode *> > sepConst_;
 
    std::vector<ConstraintPtr> sepCons_;
 
    double intTol_;
  };
  typedef TransSep* TransSepPtr;
  typedef const TransSep* ConstTransSepPtr;
}
 
#endif // MINOTAURTRANSSEP_H