Variable.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2009 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURVARIABLE_H
#define MINOTAURVARIABLE_H
 
#include <string>
 
#include "Types.h"
 
namespace Minotaur {
 
  class Variable {
  public:
    friend class AnalyticalCenter;
    friend class Linearizations;
    friend class LogHandler;
    friend class QGHandlerAdvance;
    friend class ParQGHandlerAdvance;
    friend class PerspCon;
    friend class Problem;
    friend class TransSep;
    friend class QGHandler;
    friend class OAHandler;
    friend class QuadHandler;
    friend class MultiSolHeur;
 
    Variable();
 
    Variable(UInt id, UInt index, double lb, double ub, VariableType vtype,
             std::string name);
 
    virtual ~Variable();
 
    VariablePtr clone(UInt id) const;
 
    UInt getId() const { return id_; }
 
    UInt getIndex() const { return index_; }
 
    double getInitVal() const { return initVal_; }
 
    double getLb() const { return lb_; }
 
    double getUb() const { return ub_; }
 
    VariableType getType() const { return vtype_; }
 
    FunctionType getFunType() const { return ftype_; }
 
    VarSrcType getSrcType() const { return stype_; }
 
    VarState getState() const { return state_; }
 
    UInt getNumCons() const;
 
    UInt getItmp() const;
 
    ConstrSet::iterator consBegin();
 
    ConstrSet::iterator consEnd();
 
    const std::string getName() const;
 
    void setItmp(UInt itmp);
 
    void write(std::ostream &out) const;
 
    void writeConstraintMap(std::ostream &out) const;
 
  protected:
    void setFunType_(FunctionType ftype)
    {
      ftype_ = ftype;
      return;
    }
 
    void setId_(UInt n) { id_ = n; }
 
    void setIndex_(UInt n) { index_ = n; }
 
    void setInitVal_(double val) { initVal_ = val; }
 
    void setLb_(double newLb) { lb_ = newLb; }
 
    void setName_(std::string newName) { name_ = newName; }
 
    void setSrcType(VarSrcType stype) { stype_ = stype; }
 
    void setState_(VarState state)
    {
      state_ = state;
      return;
    }
 
    void setType_(VariableType vtype);
 
    void setUb_(double newUb) { ub_ = newUb; }
 
    void outOfConstraint_(ConstraintPtr cPtr);
 
    void inConstraint_(ConstraintPtr c);
 
    void clearConstraints_();
 
  private:
    ConstrSet cons_;
 
    FunctionType ftype_;
 
    UInt id_;
 
    UInt index_;
 
    double lb_;
 
    std::string name_;
 
    double initVal_;
 
    VarState state_;
 
    VarSrcType stype_;
 
    double ub_;
 
    VariableType vtype_;
 
    Variable(const Variable &v);
 
    Variable &operator=(const Variable &v);
 
    UInt itmp_;
  };
 
  typedef std::set<std::pair<ConstraintPtr, FunctionType>>::const_iterator
      ConstraintFunIterator;
}  //namespace Minotaur
 
#endif