SolverAbstract.h

#pragma once
 
#include <cstdio>
#include <filesystem>
#include <iomanip>
#include <iostream>
#include <list>
#include <memory>
#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);
    }
  }
  ~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:
  GenericSolverException(const std::string &message)
      : std::runtime_error(message) {}
};
 
class NotImplementedFeatureSolverException : public std::runtime_error {
 public:
  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;                           
  typedef std::shared_ptr<SolverAbstract> Ptr; 
  std::list<std::ostream *>
      _streams; 
  /*************************************************************************************************
  -----------------------------------    Constructor/Desctructor
  --------------------------------
  *************************************************************************************************/
 public:
  SolverAbstract(){};
 
  SolverAbstract(const std::string &name, const SolverAbstract::Ptr toCopy){};
 
  virtual ~SolverAbstract(){};
 
  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() { return _streams; };
  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; }
  void zero_status_check(int status, const std::string &action_failed,
                         const std::string &log_location) const {
    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 copy_prob(Ptr fictif_solv) = 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_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(std::string const &name) = 0;
 
  virtual int get_col_index(std::string const &name) = 0;
 
  virtual std::vector<std::string> get_row_names(int first, int last) = 0;
 
  virtual std::vector<std::string> get_row_names() = 0;
 
  virtual std::vector<std::string> get_col_names(int first, int last) = 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 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> &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) = 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, std::string const &name) = 0;
 
  virtual void chg_col_name(int id_col, std::string const &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) = 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(std::string const &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;
};