common.h

#pragma once
 
#ifdef _MSC_VER
#pragma warning(disable : 4267) // implicit conversion, possible loss of data
#endif
 
#include <algorithm>
#include <cmath>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <json/reader.h>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <tuple>
#include <vector>
 
#include "ProblemFormat.h"
 
enum class MasterFormulation
{
    INTEGER,
    RELAXED
};
 
enum class SOLVER
{
    BENDERS,
    OUTER_LOOP,
    MERGE_MPS
};
 
struct Predicate;
typedef std::map<std::string, double> Point;
 
typedef std::shared_ptr<Point> PointPtr;
 
const double EPSILON_PREDICATE = 1e-8;
 
using problem_names = std::set<std::string>;
using VariableMap = std::map<std::string, int>;
using Int2Str = std::map<int, std::string>;
using Str2Dbl = std::map<std::string, double>;
using IntVector = std::vector<int>;
using CharVector = std::vector<char>;
using DblVector = std::vector<double>;
using StrVector = std::vector<std::string>;
using CouplingMap = std::map<std::string, VariableMap>;
 
using SlaveCutId = std::map<std::string, IntVector>;
using ActiveCut = std::tuple<int, std::string, int, bool>;
using ActiveCutStorage = std::vector<ActiveCut>;
 
using mps_coupling = std::pair<std::string, std::string>;
using mps_coupling_list = std::list<mps_coupling>;
 
enum class BENDERSMETHOD
{
    BENDERS,
    BENDERS_BY_BATCH,
    BENDERS_OUTERLOOP,
    BENDERS_BY_BATCH_OUTERLOOP
};
 
inline std::string bendersmethod_to_string(BENDERSMETHOD method)
{
    switch (method)
    {
    case BENDERSMETHOD::BENDERS:
        return "Benders";
    case BENDERSMETHOD::BENDERS_BY_BATCH:
        return "Benders by batch";
    case BENDERSMETHOD::BENDERS_OUTERLOOP:
        return "Outerloop around Benders";
    case BENDERSMETHOD::BENDERS_BY_BATCH_OUTERLOOP:
        return "Outerloop around Benders by batch";
    default:
        return "Unknown";
    }
}
 
struct Predicate
{
    bool operator()(const PointPtr& lhs, const PointPtr& rhs) const
    {
        return *lhs < *rhs;
    }
 
    bool operator()(const Point& lhs, const Point& rhs) const
    {
        Point::const_iterator it1(lhs.begin());
        Point::const_iterator it2(rhs.begin());
 
        Point::const_iterator end1(lhs.end());
        Point::const_iterator end2(rhs.end());
 
        while (it1 != end1 && it2 != end2)
        {
            if (it1->first != it2->first)
            {
                return it1->first < it2->first;
            }
            else
            {
                if (std::fabs(it1->second - it2->second) < EPSILON_PREDICATE)
                {
                    ++it1;
                    ++it2;
                }
                else
                {
                    return it1->second < it2->second;
                }
            }
        }
 
        if (it1 == end1 && it2 == end2)
        {
            return false;
        }
        else
        {
            return (it1 == end1);
        }
    }
};
 
inline std::ostream& operator<<(std::ostream& stream, const Point& rhs)
{
    for (const auto& kvp: rhs)
    {
        if (kvp.second > 0)
        {
            if (kvp.second == 1)
            {
                stream << "+";
                stream << kvp.first;
            }
            else
            {
                stream << "+";
                stream << kvp.second;
                stream << kvp.first;
            }
        }
        else if (kvp.second < 0)
        {
            stream << kvp.second;
            stream << kvp.first;
        }
    }
    return stream;
}
 
double norm_point(const Point& x0, const Point& x1);
 
std::ostream& operator<<(std::ostream& stream, const std::vector<IntVector>& rhs);
 
const std::string SUBPROBLEM_WEIGHT_CST_STR("CONSTANT");
const std::string SUBPROBLEM_WEIGHT_UNIFORM_CST_STR("UNIFORM");
const std::string WEIGHT_SUM_CST_STR("WEIGHT_SUM");
const std::string MPS_SUFFIX = ".mps";
const std::string SAVE_SUFFIX = ".svf";
 
struct BaseOptions
{
    std::string OUTPUTROOT;
    std::string INPUTROOT;
    std::string STRUCTURE_FILE;
    std::string LAST_ITERATION_JSON_FILE;
    std::string MASTER_NAME;
    ProblemsFormat PROBLEMS_FORMAT = ProblemsFormat::MPS_FILE;
    std::string SOLVER_NAME;
    std::string SLAVE_WEIGHT;
    std::string AREA_FILE;
 
    int LOG_LEVEL = 0;
 
    double SLAVE_WEIGHT_VALUE = 0;
    bool RESUME = false;
 
    Str2Dbl weights;
};
 
typedef BaseOptions MergeMPSOptions;
 
struct ExternalLoopOptions
{
    bool DO_OUTER_LOOP = false;
    std::string OUTER_LOOP_OPTION_FILE;
};
 
struct BendersBaseOptions: public BaseOptions
{
    explicit BendersBaseOptions(const BaseOptions& base_to_copy):
        BaseOptions(base_to_copy)
    {
    }
 
    int MAX_ITERATIONS = -1;
 
    double ABSOLUTE_GAP = 0;
    double RELATIVE_GAP = 0;
    double RELAXED_GAP = 0;
    double TIME_LIMIT = 0;
    double SEPARATION_PARAM = 1;
 
    bool AGGREGATION = false;
    bool TRACE = false;
    bool BOUND_ALPHA = false;
 
    MasterFormulation MASTER_FORMULATION;
 
    std::string CSV_NAME;
    std::string LAST_MASTER_MPS;
    std::string LAST_MASTER_BASIS;
 
    size_t BATCH_SIZE;
    ExternalLoopOptions EXTERNAL_LOOP_OPTIONS;
};
 
void usage(int argc);
 
Json::Value get_json_file_content(const std::filesystem::path& json_file);