constraint.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/lib/abacus/convar.h>
 
#include <ogdf/lib/abacus/infeascon.h>
#include <ogdf/lib/abacus/csense.h>
#include <ogdf/lib/abacus/conclass.h>
 
 
#pragma GCC visibility push(default)
namespace abacus {
 
class Row;
class Master;
class Variable;
class LpSub;
 
template<class BaseType, class CoType> class Active;
 
 
 
class OGDF_EXPORT Constraint : public ConVar {
 
    friend class LpSub;
 
public:
 
 
    Constraint (
        Master *master,
        const Sub *sub,
        CSense::SENSE sense,
        double rhs,
        bool dynamic,
        bool local,
        bool liftable);
 
 
 
    Constraint (Master *master);
 
 
 
    Constraint(const Constraint &rhs)
        : ConVar(rhs), sense_(rhs.sense_), rhs_(rhs.rhs_), conClass_(nullptr), liftable_(rhs.liftable_)
    {
        if (rhs.conClass_) conClass_ = new ConClass(*(rhs.conClass_));
    }
 
 
    virtual ~Constraint() { delete conClass_; }
 
 
    CSense *sense() { return &sense_; }
 
    const CSense *sense() const { return &sense_; }
 
 
 
    virtual double coeff(const Variable *v) const = 0;
 
    virtual double rhs() const { return rhs_; }
 
 
 
    bool liftable() const { return liftable_; }
 
 
 
    virtual bool valid(Sub *sub) const;
 
 
 
    virtual int genRow(Active<Variable, Constraint> *var,
        Row &row) const;
 
 
    virtual double slack(Active<Variable, Constraint> *variables,
        double *x) const;
 
 
    virtual bool violated(
        Active<Variable, Constraint> *variables, double *x, double *sl = nullptr) const;
 
 
    virtual bool violated(double slack) const;
 
 
    void printRow(std::ostream &out, Active<Variable, Constraint> *var) const;
 
 
    virtual double distance(double *x, Active<Variable, Constraint> *actVar) const;
 
    //Constraint *duplicate() { return 0; }
 
 
    ConClass *classification(Active<Variable, Constraint> *var = nullptr) const;
 
protected:
 
    virtual InfeasCon::INFEAS voidLhsViolated(double newRhs) const;
 
    virtual ConClass *classify(Active<Variable, Constraint> *var) const {
        return nullptr;
    }
 
 
    CSense sense_; 
 
    double rhs_; 
 
    mutable ConClass *conClass_; //this is just s cached-value, and hence can be set in const classify-call (it's nullptr initially, and computed upon first call
 
    bool liftable_;
 
private:
    const Constraint &operator=(const Constraint &rhs);
};
 
}
#pragma GCC visibility pop
 
#include <ogdf/lib/abacus/sub.h>
#include <ogdf/lib/abacus/master.h>
 
#pragma GCC visibility push(default)
namespace abacus {
 
inline Constraint::Constraint (
    Master *master,
    const Sub *sub,
    CSense::SENSE sense,
    double rhs,
    bool dynamic,
    bool local,
    bool liftable)
    : ConVar(master, sub, dynamic, local), sense_(sense), rhs_(rhs), conClass_(nullptr), liftable_(liftable)
{
    if (local && sub == nullptr) {
        Logger::ifout() << "Constraint::Constraint(): subtree of local item must not be 0\n";
        OGDF_THROW_PARAM(AlgorithmFailureException, ogdf::AlgorithmFailureCode::Constraint);
    }
}
 
 
inline Constraint::Constraint (Master *master)
    : ConVar(master, nullptr, true, true), conClass_(nullptr) { }
 
 
inline bool Constraint::valid(Sub *sub) const {
    OGDF_ASSERT(!local_ || sub != nullptr);
 
    return (!local_ || sub_->ancestor(sub));
}
 
}
#pragma GCC visibility pop