SimpleTransformer.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURSIMPLETRANSFORMER_H
#define MINOTAURSIMPLETRANSFORMER_H
 
#include "Transformer.h"
#include "Types.h"
 
namespace Minotaur
{
class CxUnivarHandler;
class CGraph;
class CNode;
class Environment;
class Engine;
class LinearHandler;
class LPEngine;
class Problem;
class QuadHandler;
class Solution;
class YEqCGs;
class YEqLFs;
class YEqVars;
class YEqQfBil;
typedef CxUnivarHandler* CxUnivarHandlerPtr;
typedef CGraph* CGraphPtr;
typedef LinearHandler* LinearHandlerPtr;
typedef QuadHandler* QuadHandlerPtr;
typedef Solution* SolutionPtr;
typedef const Solution* ConstSolutionPtr;
typedef LPEngine* LPEnginePtr;
typedef Engine* EnginePtr;
 
class SimpleTransformer : public Transformer
{
public:
  SimpleTransformer();
 
  SimpleTransformer(EnvPtr env, ProblemPtr p, LPEnginePtr bte, LPEnginePtr cute,
                    EnginePtr nlpe);
 
  ~SimpleTransformer();
 
  // base class method.
  std::string getName() const;
 
  // base class method.
  SolutionPtr getSolOrig(ConstSolutionPtr sol, int& err);
 
  // base class method.
  SolutionPtr getSolTrans(ConstSolutionPtr sol, int& err);
 
  // base class method.
  void reformulate(ProblemPtr& newp, HandlerVector& handlers, int& status);
 
  void writeStats(std::ostream& out) const;
 
private:
  // Store statistics of reformulation
  struct RefStats {
    double time;  
    UInt nvars;   
    UInt ncons;   
    UInt nconv;   
    UInt objConv; 
  };
 
  static const std::string me_;
 
  LPEnginePtr bte_;
 
  LPEnginePtr cute_;
 
  EnginePtr nlpe_;
 
  RefStats stats_;
 
  YEqCGs* yBiVars_;
  YEqQfBil* yQfBil_;
 
  void absRef_(LinearFunctionPtr lfl, VariablePtr vl, double dl, VariablePtr& v,
               double& d);
 
  void bilRef_(LinearFunctionPtr lfl, VariablePtr vl, double dl,
               LinearFunctionPtr lfr, VariablePtr vr, double dr,
               LinearFunctionPtr& lf, VariablePtr& v, double& d);
 
  VariablePtr newBilVar_(VariablePtr vl, VariablePtr vr);
 
  bool checkQuadConvexity_();
 
  void powKRef_(LinearFunctionPtr lfl, VariablePtr vl, double dl, double k,
                LinearFunctionPtr& lf, VariablePtr& v, double& d);
 
  void refBinxBin_(VariablePtr bin1, VariablePtr bin2, VariablePtr aux);
 
  void refBinxCont_(VariablePtr bin, VariablePtr cont, VariablePtr aux);
 
  void refNonlinCons_(ConstProblemPtr oldp);
 
  void refNonlinObj_(ConstProblemPtr oldp);
 
  void refQuadCons_(QuadraticFunctionPtr qf, LinearFunctionPtr& lf);
 
  void recursRef_(const CNode* node, LinearFunctionPtr& lf, VariablePtr& v,
                  double& d);
 
  // Reset the statistics for transformer
  void resetStats_();
 
  void trigRef_(OpCode op, LinearFunctionPtr lfl, VariablePtr vl, double dl,
                VariablePtr& v, double& d);
 
  void uniVarRef_(const CNode* n0, LinearFunctionPtr lfl, VariablePtr vl,
                  double dl, LinearFunctionPtr& lf, VariablePtr& v, double& d);
};
typedef SimpleTransformer* SimpTranPtr;
typedef const SimpleTransformer* ConstSimpTranPtr;
 
} // namespace Minotaur
 
#endif