Transformer.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURTRANSFORMER_H
#define MINOTAURTRANSFORMER_H
 
#include "OpCode.h"
#include "Types.h"
 
namespace Minotaur {
class CxUnivarHandler;
class CGraph;
class CNode;
class Environment;
class Engine;
class LinearHandler;
class LogHandler;
class Problem;
class AbsHandler;
class ExpHandler;
class PowHandler;
class QuadHandler;
class RecipHandler;
class kPowHandler;
class Solution;
class UnivarQuadHandler;
class YEqLFs;
class YEqUCGs;
class YEqVars;
typedef CxUnivarHandler *CxUnivarHandlerPtr;
typedef CGraph *CGraphPtr;
typedef LinearHandler *LinearHandlerPtr;
typedef PowHandler *PowHandlerPtr;
typedef AbsHandler *AbsHandlerPtr;
typedef RecipHandler *RecipHandlerPtr;
typedef LogHandler *LogHandlerPtr;
typedef ExpHandler *ExpHandlerPtr;
typedef QuadHandler *QuadHandlerPtr;
typedef kPowHandler *kPowHandlerPtr;
typedef UnivarQuadHandler *UnivarQuadHandlerPtr;
typedef Solution *SolutionPtr;
typedef const Solution *ConstSolutionPtr;
 
class Transformer {
 public:
  Transformer();
 
  Transformer(EnvPtr env, ProblemPtr oldp);
 
  virtual ~Transformer();
 
  virtual std::string getName() const = 0;
 
  virtual SolutionPtr getSolOrig(ConstSolutionPtr sol, int &err) = 0;
 
  virtual SolutionPtr getSolTrans(ConstSolutionPtr sol, int &err) = 0;
 
  virtual void reformulate(ProblemPtr &newp, HandlerVector &handlers,
                           int &status) = 0;
 
 protected:
  EnvPtr env_;
  AbsHandlerPtr absHandler_;
  LinearHandlerPtr lHandler_;
 
  LogHandlerPtr logHandler_;
 
  ExpHandlerPtr expHandler_;
 
  PowHandlerPtr powHandler_;
  RecipHandlerPtr recipHandler_;
 
  LoggerPtr logger_;
 
  ProblemPtr newp_;
 
  ProblemPtr p_;
 
  kPowHandlerPtr kHandler_;
 
  QuadHandlerPtr qHandler_;
 
  CxUnivarHandlerPtr uHandler_;
 
  UnivarQuadHandlerPtr uqHandler_;
 
  YEqLFs *yLfs_;
 
  YEqUCGs *yUniExprs_;
 
  YEqVars *yVars_;
std::map<VariablePtr, VariablePtr> absVarCache_;  // vl -> existing t = |vl|
  const double zTol_;
 
  bool allConsAssigned_(ProblemPtr p, HandlerVector &handlers);
 
  void assignHandler_(CGraphPtr cg, ConstraintPtr c);
 
  void clearUnusedHandlers_(HandlerVector &handlers);
 
  void copyLinear_(ConstProblemPtr p, ProblemPtr newp);
 
  void copyVars_(ConstProblemPtr p, ProblemPtr newp);
 
  virtual void makeObjLin_();
 
  void minObj_();
 
  VariablePtr newVar_(VariablePtr iv, double d, ProblemPtr newp);
 
  VariablePtr newVar_(LinearFunctionPtr lf, double d, ProblemPtr newp);
 
  VariablePtr newVar_(CGraphPtr cg, ProblemPtr newp);
 
 
 private:
  static const std::string me_;
};
 
typedef Transformer *TransformerPtr;
typedef const Transformer *ConstTransformerPtr;
 
}  // namespace Minotaur
 
#endif