ConBoundMod.h

Go to the documentation of this file.

// 
//
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURCONBOUNDMOD_H
#define MINOTAURCONBOUNDMOD_H
 
#include "Modification.h"
#include "NonlinearFunction.h"
 
namespace Minotaur {
  class Engine;
  class ConBoundMod;
  typedef Engine* EnginePtr;
  typedef ConBoundMod* ConBoundModPtr;
  typedef std::vector <ConBoundModPtr> ConBoundModVector;
  typedef ConBoundModVector::iterator ConBoundModIter;
  typedef ConBoundModVector::const_iterator ConBoundModConstIter;
 
 
  class ConBoundMod : public Modification {
    public:
      ConBoundMod(ConstraintPtr con, BoundType lu, double new_val);
 
      ~ConBoundMod();
 
      // base class method.
      ModificationPtr fromRel(RelaxationPtr, ProblemPtr ) const
      {return ModificationPtr();};
 
      // base class method.
      ModificationPtr toRel(ProblemPtr, RelaxationPtr) const
      {return ModificationPtr();};
 
      ConstraintPtr getCon() const;
 
      BoundType getLU() const;
 
      double getNewVal() const;
 
      // Implement Modification::applyToProblem().
      void applyToProblem(ProblemPtr problem);
 
      // Implement Modification::undoToProblem().
      void undoToProblem(ProblemPtr problem);
 
      // Implement Modification::write().
      void write(std::ostream &out) const;
 
    private:
      BoundType lu_;
 
      double newVal_;
 
      double oldVal_;
 
      ConstraintPtr con_;
  };
 
  class ConBoundMod2;
  typedef ConBoundMod2* ConBoundMod2Ptr;
  typedef const ConBoundMod2* ConstConBoundMod2Ptr;  
  typedef std::vector < ConBoundMod2Ptr > ConBoundMod2Vector;
  typedef ConBoundMod2Vector::iterator ConBoundMod2Iter;
  typedef ConBoundMod2Vector::const_iterator ConBoundMod2ConstIter;
 
  class ConBoundMod2 : public Modification {
    public:
      ConBoundMod2(ConstraintPtr con, double new_lb, double new_ub);
 
      ~ConBoundMod2();
 
      // Implement Modification::applyToProblem().
      void applyToProblem(ProblemPtr problem);
 
      // base class method.
      ModificationPtr fromRel(RelaxationPtr, ProblemPtr ) const
      {return ModificationPtr();};
 
      ConstraintPtr getCon() const;
 
      double getNewLb() const;
 
      double getNewUb() const;
 
      // base class method.
      ModificationPtr toRel(ProblemPtr, RelaxationPtr) const
      {return ModificationPtr();};
 
      // Implement Modification::undoToProblem().
      void undoToProblem(ProblemPtr problem);
 
      // Implement Modification::write().
      void write(std::ostream &) const {};
 
    private:
      double newLb_;
 
      double newUb_;
 
      double oldLb_;
 
      double oldUb_;
 
      ConstraintPtr con_;
  };
 
 
  class ConMod;
  typedef ConMod* ConModPtr;
  typedef const ConMod* ConstConModPtr;  
  typedef std::vector < ConModPtr > ConModVector;
  typedef ConModVector::iterator ConModIter;
  typedef ConModVector::const_iterator ConModConstIter;
 
  class ConMod : public Modification {
    public:
      ConMod(ConstraintPtr con, NonlinearFunctionPtr new_nlf);
 
      ~ConMod();
 
      // Implement Modification::applyToProblem().
      void applyToProblem(ProblemPtr problem);
 
      // base class method.
      ModificationPtr fromRel(RelaxationPtr, ProblemPtr ) const
      {return ModificationPtr();};
 
      ConstraintPtr getCon() const;
 
      NonlinearFunctionPtr getNewNlf() const;
 
 
      // base class method.
      ModificationPtr toRel(ProblemPtr, RelaxationPtr) const
      {return ModificationPtr();};
 
      // Implement Modification::undoToProblem().
      void undoToProblem(ProblemPtr problem);
 
      // Implement Modification::write().
      void write(std::ostream &) const {};
 
    private:
      NonlinearFunctionPtr newNlf_;
 
 
      NonlinearFunctionPtr oldNlf_;
 
      ConstraintPtr con_;
  };
 
}
 
#endif