LpSolver.h

#pragma once
 
#include <iosfwd>
#include <memory>
#include <span>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "delpi/libs/gmp.h"
#include "delpi/solver/Column.h"
#include "delpi/solver/LpResult.h"
#include "delpi/solver/LpRowSense.h"
#include "delpi/solver/LpStats.h"
#include "delpi/solver/Row.h"
#include "delpi/symbolic/Expression.h"
#include "delpi/symbolic/Formula.h"
#include "delpi/symbolic/Variable.h"
#include "delpi/util/Config.h"
#include "delpi/util/Stats.h"
#include "delpi/util/concepts.h"
 
namespace delpi {

class LpSolver {
 public:
  using ColumnIndex = int;
  using RowIndex = int;
  using SolveCallback =
      std::function<void(const LpSolver& lp_solver, LpResult result, const std::vector<mpq_class>& x,
                         const std::vector<mpq_class>& y, const mpq_class& obj_lb, const mpq_class& obj_ub)>;
  using PartialSolveCallback =
      std::function<bool(const LpSolver& lp_solver, LpResult result, const std::vector<mpq_class>& x,
                         const std::vector<mpq_class>& y, const mpq_class& obj_lb, const mpq_class& obj_ub)>;
 
  static std::unique_ptr<LpSolver> GetInstance(const Config& config);

  LpSolver(mpq_class ninfinity, mpq_class infinity, Config config = {}, const std::string& class_name = "LpSolver");
  virtual ~LpSolver() = default;

  bool Parse();
  bool ParseFile(const std::string& filename);
  bool ParseString(const std::string& string);
  bool ParseStream(std::istream& stream, const std::string& stream_name = "(stdin)");

  [[nodiscard]] virtual int num_columns() const = 0;
  [[nodiscard]] virtual int num_rows() const = 0;
  [[nodiscard]] const mpq_class& ninfinity() const { return ninfinity_; }
  [[nodiscard]] const mpq_class& infinity() const { return infinity_; }
  [[nodiscard]] const LpStats& stats() const { return stats_; }
  [[nodiscard]] const Config& config() const { return config_; }
  [[nodiscard]] const std::vector<mpq_class>& solution() const { return solution_; }
  [[nodiscard]] const std::vector<mpq_class>& dual_solution() const { return dual_solution_; }
  [[nodiscard]] const mpq_class& obj_lb() const { return obj_lb_; }
  [[nodiscard]] const mpq_class& obj_ub() const { return obj_ub_; }
  [[nodiscard]] bool is_min() const { return is_min_; }

  [[nodiscard]] const std::unordered_map<Variable, int>& var_to_col() const { return var_to_col_; }
  [[nodiscard]] const std::vector<Variable>& variables() const { return col_to_var_; }
  [[nodiscard]] std::vector<Formula> constraints() const;
  [[nodiscard]] LpResult expected() const;
  [[nodiscard]] std::unordered_map<Variable, mpq_class> model() const;
  [[nodiscard]] const SolveCallback& solve_cb() const { return solve_cb_; }
  [[nodiscard]] SolveCallback& m_solve_cb() { return solve_cb_; }
  [[nodiscard]] const PartialSolveCallback& partial_solve_cb() const { return partial_solve_cb_; }
  [[nodiscard]] PartialSolveCallback& m_partial_solve_cb() { return partial_solve_cb_; }
  [[nodiscard]] const std::unordered_map<std::string, std::string>& info() const { return info_; }

  [[nodiscard]] std::unordered_map<Variable, mpq_class> model(const std::vector<mpq_class>& x) const;
  [[nodiscard]] const mpq_class& solution(const Variable var) const { return solution_.at(var_to_col_.at(var)); }

  [[nodiscard]] const Variable& var(const int column) const { return col_to_var_.at(column); }
  [[nodiscard]] virtual Column column(int column_idx) const = 0;
  [[nodiscard]] virtual Row row(int row_idx) const = 0;
  virtual void ReserveColumns(int size);
  virtual void ReserveRows(int size);

  const std::string& GetInfo(const std::string& key) const;
  void SetInfo(const std::string& key, const std::string& value);
  void SetOption(const std::string& key, const std::string& value);

  virtual void AddColumns(const std::span<Column>& columns);
  ColumnIndex AddColumn(const Column& column);
  ColumnIndex AddColumn(const Variable& var);
  ColumnIndex AddColumn(const Variable& var, const mpq_class& obj);
  ColumnIndex AddColumn(const Variable& var, const mpq_class& lb, const mpq_class& ub);
  virtual ColumnIndex AddColumn(const Variable& var, const mpq_class& obj, const mpq_class& lb,
                                const mpq_class& ub) = 0;

  virtual void AddRows(const std::span<Row>& rows);
  RowIndex AddRow(const Row& row);
  virtual RowIndex AddRow(const std::vector<std::pair<Variable, mpq_class>>& addends, const mpq_class& lb,
                          const mpq_class& ub) = 0;
  RowIndex AddRow(const Formula& formula);
  RowIndex AddRow(const Expression& lhs, FormulaKind sense, const mpq_class& rhs);
  virtual RowIndex AddRow(const Expression::Addends& lhs, FormulaKind sense, const mpq_class& rhs) = 0;

  virtual void SetCoefficient(RowIndex row, ColumnIndex column, const mpq_class& value) = 0;

  void SetObjective(const Expression& objective);
  void SetObjective(const std::unordered_map<int, mpq_class>& objective);
  void SetObjective(const std::vector<mpq_class>& objective);
  void SetObjective(const Variable& var, const mpq_class& value);
  virtual void SetObjective(int column, const mpq_class& value) = 0;

  virtual void SetBound(Variable var, const mpq_class& lb, const mpq_class& ub) = 0;

  LpResult Solve();

  void Maximise(const Expression& objective_function);
  template <TypedIterable<std::pair<const Variable, mpq_class>> T>
  void Maximise(const T& objective_function);
  void Minimise(const Expression& objective_function);
  template <TypedIterable<std::pair<const Variable, mpq_class>> T>
  void Minimise(const T& objective_function);

  void ResetObjective();

  [[nodiscard]] bool CheckAgainstExpected(LpResult result) const;

  bool Verify() const;
 
#ifndef NDEBUG
  virtual void Dump() = 0;
#endif
 
 protected:
  void EnsureSense(bool is_min);

  virtual void EnsureSenseCore() = 0;

  virtual LpResult SolveCore() = 0;

  bool SetSimpleBoundInsteadOfAddRow(const std::vector<Expression::Addend>& addends, const mpq_class& lb,
                                     const mpq_class& ub);
 
  Config config_;                                      
  LpStats stats_;                                      
  std::unordered_map<std::string, std::string> info_;  
 
  std::unordered_map<Variable, int> var_to_col_;  
  std::vector<Variable> col_to_var_;              
  std::vector<mpq_class> solution_;               
  std::vector<mpq_class> dual_solution_;          
  mpq_class obj_lb_;                              
  mpq_class obj_ub_;                              
 
  SolveCallback solve_cb_;                 
  PartialSolveCallback partial_solve_cb_;  
 
  bool is_min_;          
  mpq_class ninfinity_;  
  mpq_class infinity_;   
};
 
std::ostream& operator<<(std::ostream& os, const LpSolver& solver);
 
}  // namespace delpi
 
#ifdef DELPI_INCLUDE_FMT
 
#include "delpi/util/logging.h"
 
OSTREAM_FORMATTER(delpi::LpSolver);
 
#endif