SolverAbstract.h

#pragma once
 
#include <cstdio>
#include <filesystem>
#include <iomanip>
#include <iostream>
#include <list>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <span>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "antares-xpansion/xpansion_interfaces/LogUtils.h"
 
class SolverLogManager
{
public:
    explicit SolverLogManager() = default;
 
    explicit SolverLogManager(const SolverLogManager& other):
        SolverLogManager(other.log_file_path)
    {
    }
 
    explicit SolverLogManager(const std::filesystem::path& log_file):
        log_file_path(log_file)
    {
        init();
    }
 
    SolverLogManager& operator=(const SolverLogManager& other)
    {
        if (this == &other)
        {
            return *this;
        }
        log_file_path = other.log_file_path;
        init();
        return *this;
    }
 
    void init()
    {
#ifdef __linux__
        if (log_file_path.empty()
            || (log_file_ptr = fopen(log_file_path.string().c_str(), "a+")) == nullptr)
#elif _WIN32
        if (log_file_path.empty()
            || (log_file_ptr = _fsopen(log_file_path.string().c_str(), "a+", _SH_DENYNO))
                 == nullptr)
#endif
        {
            std::cout << "Invalid log file name passed as parameter: "
                      << std::quoted(log_file_path.string()) << std::endl;
        }
        else
        {
            setvbuf(log_file_ptr, nullptr, _IONBF, 0);
        }
    }
 
    virtual ~SolverLogManager()
    {
        if (log_file_ptr)
        {
            fclose(log_file_ptr);
            log_file_ptr = nullptr;
        }
    }
 
    FILE* log_file_ptr = nullptr;
    std::filesystem::path log_file_path = "";
};
 
class InvalidStatusException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidStatusException(int status, const std::string& action, const std::string& log_message):
        LogUtils::XpansionError<std::runtime_error>("Failed to " + action + ": invalid status "
                                                      + std::to_string(status) + " (0 expected)",
                                                    log_message)
    {
    }
};
 
class InvalidRowSizeException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidRowSizeException(int expected_size, int actual_size, const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>(
          "Invalid row size for solver. " + std::to_string(actual_size) + " rows available ("
            + std::to_string(expected_size) + " expected)",
          log_location)
    {
    }
};
 
class InvalidColSizeException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidColSizeException(int expected_size, int actual_size, const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>(
          "Invalid col size for solver. " + std::to_string(actual_size) + " cols available ("
            + std::to_string(expected_size) + " expected)",
          log_location)
    {
    }
};
 
class InvalidBoundTypeException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidBoundTypeException(char qbtype, const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>(std::string("Invalid bound type ") + qbtype
                                                      + " for solver.",
                                                    log_location)
    {
    }
};
 
class InvalidColTypeException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidColTypeException(char qctype, const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>(std::string("Invalid col type ") + qctype
                                                      + " for solver.",
                                                    log_location)
    {
    }
};
 
class InvalidSolverOptionException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidSolverOptionException(const std::string& option, const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>(std::string("Invalid option '") + option
                                                      + "' for solver.",
                                                    log_location)
    {
    }
};
 
class InvalidSolverForCopyException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidSolverForCopyException(const std::string& from_solver,
                                  const std::string& to_solver,
                                  const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>("Can't copy " + from_solver + "solver from "
                                                      + to_solver,
                                                    log_location)
    {
    }
};
 
class InvalidSolverNameException: public LogUtils::XpansionError<std::runtime_error>
{
public:
    InvalidSolverNameException(const std::string& solver_name, const std::string& log_location):
        LogUtils::XpansionError<std::runtime_error>("Solver '" + solver_name + "' not supported",
                                                    log_location)
    {
    }
};
 
class GenericSolverException: public std::runtime_error
{
public:
    explicit GenericSolverException(const std::string& message):
        std::runtime_error(message)
    {
    }
};
 
class NotImplementedFeatureSolverException: public std::runtime_error
{
public:
    explicit NotImplementedFeatureSolverException(const std::string& message):
        std::runtime_error(message)
    {
    }
};
 
// Definition of optimality codes
enum SOLVER_STATUS
{
    OPTIMAL,
    INFEASIBLE,
    UNBOUNDED,
    INForUNBOUND,
    UNKNOWN,
};
 
class SolverAbstract
{
public:
    std::vector<std::string> SOLVER_STRING_STATUS = {"OPTIMAL",
                                                     "INFEASIBLE",
                                                     "UNBOUNDED",
                                                     "INForUNBOUND",
                                                     "UNKNOWN"};
 
    /*************************************************************************************************
    ----------------------------------------    ATTRIBUTES
    ---------------------------------------
    *************************************************************************************************/
 
public:
    std::string _name; 
    mutable std::list<std::ostream*>
      _streams; 
    /*************************************************************************************************
    -----------------------------------    Constructor/Desctructor
    --------------------------------
    *************************************************************************************************/
 
public:
    virtual ~SolverAbstract() = default;
    virtual SolverAbstract* clone() const = 0;
    virtual int get_number_of_instances() = 0;
 
    virtual std::string get_solver_name() const = 0;
 
    /*************************************************************************************************
    -----------------------------------    Output stream management
    ------------------------------
    *************************************************************************************************/
 
public:
    std::list<std::ostream*>& get_stream() const;
 
    FILE* _fp = nullptr;
    std::filesystem::path _log_file = "";
 
    void add_stream(std::ostream& stream)
    {
        get_stream().push_back(&stream);
    }
 
    void set_fp(FILE* fp)
    {
        _fp = fp;
    }
 
    static void zero_status_check(int status,
                                  const std::string& action_failed,
                                  const std::string& log_location)
    {
        if (status != 0)
        {
            throw InvalidStatusException(status, action_failed, log_location);
        }
    }
 
    /*************************************************************************************************
    ------    Destruction or creation of inner strctures and datas, closing
    environments    ----------
    *************************************************************************************************/
 
public:
    virtual void init() = 0;
 
    virtual void free() = 0;
 
    /*************************************************************************************************
    -------------------------------    Reading & Writing problems
    -------------------------------
    *************************************************************************************************/
 
public:
    virtual void write_prob_mps(const std::filesystem::path& filename) = 0;
 
    virtual void write_prob_lp(const std::filesystem::path& filename) = 0;
 
    virtual void save_prob(const std::filesystem::path& filename) = 0;
 
    virtual void write_basis(const std::filesystem::path& filename) = 0;
 
    virtual void read_prob_mps(const std::filesystem::path& filename) = 0;
 
    virtual void read_prob_lp(const std::filesystem::path& filename) = 0;
 
    virtual void restore_prob(const std::filesystem::path& filename) = 0;
 
    virtual void read_basis(const std::filesystem::path& filename) = 0;
 
    virtual void set_basis(std::span<int> rstatus, std::span<int> cstatus) = 0;
 
    /*************************************************************************************************
    -----------------------    Get general informations about problem
    ----------------------------
    *************************************************************************************************/
 
public:
    virtual int get_ncols() const = 0;
 
    virtual int get_nrows() const = 0;
 
    virtual int get_nelems() const = 0;
 
    virtual int get_n_integer_vars() const = 0;
 
    virtual void get_obj(double* obj, int first, int last) const = 0;
 
    virtual void set_obj_to_zero() = 0;
 
    virtual void set_obj(const double* obj, int first, int last) = 0;
 
    virtual void get_rows(int* mstart,
                          int* mclind,
                          double* dmatval,
                          int size,
                          int* nels,
                          int first,
                          int last) const
      = 0;
 
    virtual void get_row_type(char* qrtype, int first, int last) const = 0;
 
    virtual void get_rhs(double* rhs, int first, int last) const = 0;
 
    virtual void get_rhs_range(double* range, int first, int last) const = 0;
 
    virtual void get_cols(int* mstart,
                          int* mrwind,
                          double* dmatval,
                          int size,
                          int* nels,
                          int first,
                          int last) const
      = 0;
 
    virtual void get_col_type(char* coltype, int first, int last) const = 0;
 
    virtual void get_lb(double* lb, int fisrt, int last) const = 0;
 
    virtual void get_ub(double* ub, int fisrt, int last) const = 0;
 
    virtual int get_row_index(const std::string& name) = 0;
 
    virtual int get_col_index(const std::string& name) = 0;
 
    virtual std::vector<std::string> get_row_names(int first, int last) const = 0;
 
    virtual std::vector<std::string> get_row_names() = 0;
 
    virtual std::vector<std::string> get_col_names(int first, int last) const = 0;
 
    virtual std::vector<std::string> get_col_names() = 0;
 
    /*************************************************************************************************
    ------------------------------    Methods to modify problem
    ----------------------------------
    *************************************************************************************************/
 
public:
    virtual void del_rows(int first, int last) = 0;
 
    virtual void del_cols(int first, int last) = 0;
 
    virtual void add_rows(int newrows,
                          int newnz,
                          const char* qrtype,
                          const double* rhs,
                          const double* range,
                          const int* mstart,
                          const int* mclind,
                          const double* dmatval,
                          const std::vector<std::string>& row_names)
      = 0;
 
    virtual void add_cols(int newcol,
                          int newnz,
                          const double* objx,
                          const int* mstart,
                          const int* mrwind,
                          const double* dmatval,
                          const double* bdl,
                          const double* bdu,
                          const std::vector<std::string>& col_names)
      = 0;
 
    virtual void add_name(int type, const char* cnames, int indice) = 0;
 
    virtual void add_names(int type, const std::vector<std::string>& cnames, int first, int end)
      = 0;
 
    virtual void chg_obj(const std::vector<int>& mindex, const std::vector<double>& obj) = 0;
 
    virtual void chg_obj_direction(const bool minimize) = 0;
 
    virtual void chg_bounds(const std::vector<int>& mindex,
                            const std::vector<char>& qbtype,
                            const std::vector<double>& bnd)
      = 0;
 
    virtual void chg_col_type(const std::vector<int>& mindex, const std::vector<char>& qctype) = 0;
 
    virtual void chg_rhs(int id_row, double val) = 0;
 
    virtual void chg_coef(int id_row, int id_col, double val) = 0;
 
    virtual void chg_row_name(int id_row, const std::string& name) = 0;
 
    virtual void chg_col_name(int id_col, const std::string& name) = 0;
 
    /*************************************************************************************************
    -----------------------------    Methods to solve the problem
    ---------------------------------
    *************************************************************************************************/
 
public:
    virtual int solve_lp() = 0;
 
    virtual int solve_mip() = 0;
 
    /*************************************************************************************************
    -------------------------    Methods to get solutions information
    -----------------------------
    *************************************************************************************************/
 
public:
    virtual void get_basis(int* rstatus, int* cstatus) const = 0;
 
    virtual double get_mip_value() const = 0;
 
    virtual double get_lp_value() const = 0;
 
    virtual int get_splex_num_of_ite_last() const = 0;
 
    virtual void get_lp_sol(double* primals, double* duals, double* reduced_costs) const = 0;
 
    virtual void get_mip_sol(double* primals) = 0;
 
    /*************************************************************************************************
    ------------------------    Methods to set algorithm or logs levels
    ---------------------------
    *************************************************************************************************/
 
public:
    virtual void set_output_log_level(int loglevel) = 0;
 
    virtual void set_algorithm(const std::string& algo) = 0;
 
    virtual void set_threads(int n_threads) = 0;
 
    virtual void set_optimality_gap(double gap) = 0;
 
    virtual void set_simplex_iter(int iter) = 0;
 
    virtual void mark_indices_to_keep_presolve(int nrows, int ncols, int* rowind, int* colind) = 0;
 
    virtual void presolve_only() = 0;
 
    virtual void get_presolve_map(int* rowmap, int* colmap) const = 0;
 
    bool operator==(const SolverAbstract&) const;
};