lpsub.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/lib/abacus/lp.h>
 
 
namespace abacus {
 
class InfeasCon;
class Sub;
class Master;
class FSVarStat;
class Constraint;
class Variable;
 
 
 
class OGDF_EXPORT LpSub : public virtual LP {
 
    friend class Sub;
    friend class SetBranchRule;
    friend class BoundBranchRule;
    friend class ValBranchRule;
    friend class ConBranchRule;
    friend class COPBRANCHRULE;
 
public:
 
 
    LpSub (Master *master, const Sub *sub);
 
 
    virtual ~LpSub();
 
    const Sub *sub() const { return sub_; }
 
 
    int trueNCol() const { return LP::nCol(); }
 
    int trueNnz() const { return LP::nnz(); }
 
 
    double lBound(int i)  const;
 
    /***
     * \param i The number of a variable.
     *
     * \return The upper bound of variable \a i. If a variable is eliminated, we
     *         return the value the eliminated variable is fixed or set to.
     */
    double uBound(int i)  const;
 
 
    virtual double value() const override { return LP::value() + valueAdd_; }
 
 
    virtual double xVal(int i) const override;
 
 
    virtual double barXVal(int i) const override;
 
 
    virtual double reco(int i) const override;
 
 
    virtual LPVARSTAT::STATUS lpVarStat(int i) const override;
 
 
 
    virtual int getInfeas(int &infeasCon, int &infeasVar, double *bInvRow) const override;
 
    virtual bool infeasible() const override {
        return (LP::infeasible() || infeasCons_.size());
    }
 
    ArrayBuffer<InfeasCon*> *infeasCon() { return &infeasCons_; }
 
 
    virtual void loadBasis(Array<LPVARSTAT::STATUS> &lpVarStat,
        Array<SlackStat::STATUS> &slackStat) override;
 
protected:
 
 
    virtual void initialize();
 
private:
 
 
    virtual OPTSTAT optimize(METHOD method) override;
 
    virtual void removeCons(ArrayBuffer<int> &ind) {
        LP::remRows(ind);
    }
 
    virtual void removeVars(ArrayBuffer<int> &vars);
 
    virtual void addCons(ArrayBuffer<Constraint*> &newCons);
 
    virtual void addVars(
        ArrayBuffer<Variable*> &vars,
        ArrayBuffer<FSVarStat*> &fsVarStat,
        ArrayBuffer<double> &lb,
        ArrayBuffer<double> &ub);
 
 
    virtual void changeLBound(int i, double newLb) override;
 
 
    virtual void changeUBound(int i, double newUb) override;
 
    virtual void varRealloc(int newSize);
 
    virtual void conRealloc(int newSize);
 
    void constraint2row(ArrayBuffer<Constraint*> &newCons,
        ArrayBuffer<Row*> &newRows);
 
 
    bool eliminable(int i) const;
 
 
    bool eliminated(int i) const {
        return (orig2lp_[i] == -1);
    }
 
 
    virtual double elimVal(int i) const;
 
 
    virtual double elimVal(FSVarStat *stat, double lb, double ub) const;
 
    void initialize(
        OptSense sense,
        int nRow,
        int maxRow,
        int nCol,
        int maxCol,
        Array<double> &obj,
        Array<double> &lBound,
        Array<double> &uBound,
        Array<Row*> &rows);
 
    void initialize(
        OptSense sense,
        int nRow,
        int maxRow,
        int nCol,
        int maxCol,
        Array<double> &obj,
        Array<double> &lBound,
        Array<double> &uBound,
        Array<Row*> &rows,
        Array<LPVARSTAT::STATUS> &lpVarStat,
        Array<SlackStat::STATUS> &slackStat);
 
    int    nCol()     const;
    int    maxCol()   const;
    int    nnz()      const;
    double obj(int i) const;
 
    void rowRealloc(int newSize);
    void colRealloc(int newSize);
 
 
    const Sub *sub_;
 
    Array<int> orig2lp_;
 
    Array<int> lp2orig_;
 
    ArrayBuffer<InfeasCon*> infeasCons_;
 
    double valueAdd_;
 
    int nOrigVar_;
 
    LpSub(const LpSub &rhs);
    const LpSub &operator=(const LpSub &rhs);
};
 
}
 
#include <ogdf/lib/abacus/sub.h>
 
namespace abacus {
 
inline LpSub::LpSub (Master *master, const Sub *sub)
    :
    LP(master),
    sub_(sub),
    orig2lp_(sub->maxVar()),
    lp2orig_(sub->maxVar()),
    infeasCons_(sub->maxCon(),false)
{ }
 
}