Constraint.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURCONSTRAINT_H
#define MINOTAURCONSTRAINT_H
 
#include <string>
 
#include "Function.h"
#include "Types.h"
#include "Variable.h"
 
namespace Minotaur
{
typedef std::set<std::pair<VariablePtr, FunctionType>>::const_iterator
    VariableFunIterator;
 
class Constraint
{
public:
  friend class Problem;
  friend class PerspCon;
  friend class TransSep;
  friend class QGHandler;
 
  Constraint();
 
  Constraint(UInt id, UInt index, FunctionPtr f, double lb, double ub,
             std::string name);
 
  virtual ~Constraint();
 
  double getActivity(const double* x, int* error) const;
 
  bool getBFlag() const
  {
    return bTemp_;
  }
 
  int getITemp() const
  {
    return iTemp_;
  }
 
  void setITemp(int i) 
  {
    iTemp_ = i;
  }
 
 
  FunctionPtr getFunction() const
  {
    return f_;
  }
 
  FunctionType getFunctionType() const;
 
  UInt getId() const
  {
    return id_;
  }
 
  UInt getIndex() const
  {
    return index_;
  }
 
  double getLb() const
  {
    return lb_;
  }
 
  LinearFunctionPtr getLinearFunction() const;
 
  // Get the name of the constraint.
  const std::string getName() const;
 
  NonlinearFunctionPtr getNonlinearFunction() const;
 
  QuadraticFunctionPtr getQuadraticFunction() const;
 
  ConsState getState() const
  {
    return state_;
  }
 
  ConsSrcType getSrcType() const
  {
    return src_;
  }
 
  ConsType getType() const
  {
    return type_;
  }
 
  double getUb() const
  {
    return ub_;
  }
 
  void setpId(UInt n)
  {
    pid_ = n;
  }
 
  int getpId()
  {
    return pid_;
  }
 
  void setUB(double newub)
  {
    ub_ = newub;
  }
 
  Convexity getConvexity()
  {
    return convex_;
  }
 
  void setConvexity(Convexity convex)
  {
    convex_ = convex;
  }
 
  void incrAct()
  {
    numAct_++;
  }
 
  void setBFlag(bool b)
  {
    bTemp_ = b;
  }
 
  void setSrcType(ConsSrcType src)
  {
    src_ = src;
  }
 
  void setType(ConsType type)
  {
    type_ = type;
  }
 
  void write(std::ostream& out) const;
 
protected:
  void add_(double cb);
 
  void changeLf_(LinearFunctionPtr lf);
 
  void changeNlf_(NonlinearFunctionPtr nlf);
 
  void delFixedVar_(VariablePtr v, double val);
 
  void reverseSense_();
 
  void setId_(UInt n)
  {
    id_ = n;
  }
 
  void setIndex_(UInt n)
  {
    index_ = n;
  }
 
  void setLb_(double newlb)
  {
    lb_ = newlb;
  }
 
  void setName_(std::string name);
 
  void setState_(ConsState state)
  {
    state_ = state;
    return;
  }
 
  void setUb_(double newub)
  {
    ub_ = newub;
  }
 
  void subst_(VariablePtr out, VariablePtr in, double rat, bool* instay);
 
private:
  FunctionPtr f_;
 
  UInt numAct_;
  UInt id_;
 
  //linearization (-1 for objective)
  int pid_;
 
  UInt index_;
 
  double lb_;
 
  std::string name_;
 
  ConsSrcType src_;
 
  ConsState state_;
 
  ConsType type_;
 
  bool bTemp_;
 
  int iTemp_;
 
  double ub_;
 
  Convexity convex_;
};
} // namespace Minotaur
#endif