lp_util.hpp

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef CMR_LP_UTIL_H
#define CMR_LP_UTIL_H

#include <iostream>
#include <memory>
#include <stdexcept>
#include <utility>
#include <vector>


namespace CMR {

namespace LP {

namespace CutAge {

constexpr int Babby = -1; 
constexpr int PivOld = 30; 
constexpr int TourOld = 20; 

}

enum class PivType {
    Frac, 
    Subtour, 
    Tour, 
    FathomedTour 
};

enum class SolStat {
    Optimal, 
    Infeas, 
    Abort 
};

inline std::ostream &operator<<(std::ostream &os, SolStat stat)
{
    if (stat == SolStat::Optimal)
        os << "Optimal";
    else if (stat == SolStat::Infeas)
        os << "Infeasible";
    else if (stat == SolStat::Abort)
        os << "Limit Abort";
    else
        throw std::logic_error("Unimplemented SolStat ostream<<");

    return os;
}

inline bool is_tour_piv(PivType P)
{
    return P == PivType::Tour || P == PivType::FathomedTour;
}

enum BStat {
    AtLower = 0, 
    Basic = 1, 
    AtUpper = 2, 
    FreeSuper = 3 
};

struct Basis {
    Basis() = default;
    Basis(Basis &&B) noexcept
        : colstat(std::move(B.colstat)), rowstat(std::move(B.rowstat)) {}

    Basis &operator=(Basis &&B) noexcept
        {
            colstat = std::move(B.colstat);
            rowstat = std::move(B.rowstat);
            return *this;
        }

    bool empty() const { return colstat.empty() || rowstat.empty(); }

    std::vector<int> colstat; 
    std::vector<int> rowstat; 

    using Ptr = std::unique_ptr<Basis>;
};

struct Estimate {
    Estimate() = default;

    Estimate(double val)
        : sol_stat(Stat::Abort), value(val), sb_base()  {}

    Estimate(Estimate &&E) noexcept
        : sol_stat(E.sol_stat), value(E.value), sb_base(std::move(E.sb_base))
        {}

    Estimate &operator=(Estimate &&E) noexcept
        {
            sol_stat = E.sol_stat;
            value = E.value;
            sb_base = std::move(E.sb_base);

            return *this;
        }

    enum class Stat {
        Abort, 
        Infeas, 
        Prune 
    } sol_stat;

    double value; 

    Basis::Ptr sb_base;
};

inline std::ostream &operator<<(std::ostream &os, Estimate::Stat estat)
{
    using Estat = Estimate::Stat;
    if (estat == Estat::Prune)
        os << "Prunable";
    else if (estat == Estat::Infeas)
        os << "Infeasible";
    else if (estat == Estat::Abort)
        os << "Limit Abort";
    else
        throw std::logic_error("Unimplemented Estimate::Stat ostream<<");

    return os;
}

struct SparseRow {
    std::vector<int> rmatind; 
    std::vector<double> rmatval; 
    char sense = '\0'; 
    double rhs = 0.0; 
    double lp_viol = 0.0; 
};

inline std::ostream &operator<<(std::ostream &os, PivType piv)
{
    using Ptype = LP::PivType;

    if (piv == Ptype::Frac)
        os << "Fractional";
    else if (piv == Ptype::Subtour)
        os << "Integral subtour";
    else if (piv == Ptype::Tour)
        os << "Tour";
    else if (piv == Ptype::FathomedTour)
        os << "Optimal tour";

    return os;
}


}
}

#endif