qbpp_abs2.hpp

Go to the documentation of this file.

 
#ifndef QBPP_ABS2_HPP
#define QBPP_ABS2_HPP
 
#include <algorithm>
 
#include "abs2.hpp"
#include "qbpp.hpp"
 
namespace qbpp_abs2 {
 
//===========================
// Class forward declarationsmake
//===========================
class Solver;
class QuadModel;
class Param;
class Sol;
class Callback;
 
//===================
// Class declarations
//===================
 
 
class Solver : public abs2::Solver {
 public:
  Sol operator()(const QuadModel &quad_model, Param &param) const;
 
  Sol operator()(const QuadModel &quad_model, Param &param,
                 const Sol &start) const;
 
};
 
class QuadModel : public qbpp::QuadModel {
  std::shared_ptr<abs2::Model> abs2model_ptr;
 
  QuadModel() = delete;
 
 public:
  QuadModel(const qbpp::QuadModel &quad_model);
 
  QuadModel(const QuadModel &quad_model)
      : qbpp::QuadModel(quad_model), abs2model_ptr(quad_model.abs2model_ptr) {};
 
  const abs2::Model &get_abs2_model() const { return *abs2model_ptr; }
};
 
class Param : public abs2::Param {
  std::optional<qbpp::energy_t> target_energy;
 
 public:
 
  Param() = default;
 
  void set_target_energy(qbpp::energy_t target_energy) {
    this->target_energy = target_energy;
  }
 
  std::optional<qbpp::energy_t> get_target_energy() const {
    return target_energy;
  }
 
  void set_time_limit(uint32_t time_limit) {
    abs2::Param::set("time_limit", std::to_string(time_limit));
  }
 
  void set_arithmetic_bits(uint32_t bits) {
    abs2::Param::set("arithmetic_bits", std::to_string(bits));
  }
 
};
 
class Sol : public qbpp::Sol {
  const std::shared_ptr<abs2::Sol> abs2sol_ptr;
 
 public:
 
  Sol(const QuadModel &quad_model, const abs2::Sol &sol);
 
  Sol(const qbpp::Sol &sol);
 
 
  Sol(const Sol &sol) = default;
 
  void print(const std::string &attrs) const { abs2sol_ptr->print(attrs); }
 
  void set(int index, bool value) {
    qbpp::Sol::set(index, value);
    abs2sol_ptr->set(index, value);
  }
 
  void set(qbpp::Var var, bool value) {
    qbpp::Sol::set(var, value);
    abs2sol_ptr->set(get_index(var), value);
  }
 
  double get_tts() const { return std::stod(abs2sol_ptr->get("tts")); }
 
  const std::shared_ptr<abs2::Sol> get_abs2sol_ptr() const {
    return abs2sol_ptr;
  }
};
 
class Callback : public abs2::Callback {
 protected:
  const QuadModel quad_model;
 
 public:
 
  Callback(const QuadModel &quad_model)
      : abs2::Callback(), quad_model(quad_model) {};
 
  virtual ~Callback() = default;
 
  Sol get_sol() const { return Sol(quad_model, abs2::Callback::get()); };
 
  void set_hint(const Sol &hint) {
    abs2::Callback::set(*hint.get_abs2sol_ptr());
  }
  virtual void callback(const std::string &event) {
    if (event == "init") {
      qbpp_abs2::Callback::set("new");
    } else if (event == "new") {
      auto sol = get_sol();
      std::cout << "TTS = " << std::fixed << std::setprecision(3)
                << sol.get_tts() << "s Energy=" << sol.get_energy()
                << std::endl;
    }
  }
 
 
};  // namespace qbpp_abs2
 
//============================
// Class QuadModel member function
//============================
inline QuadModel::QuadModel(const qbpp::QuadModel &quad_model)
    : qbpp::QuadModel(quad_model) {
  // Create an empty ABS2 model
  abs2model_ptr = std::make_unique<abs2::Model>(
      var_count(), quad_model.get_min_coeff(), quad_model.get_max_coeff());
 
  // Set the linear and quadratic terms
  for (qbpp::vindex_t i = 0; i < var_count(); i++) {
    if (quad_model.get_linear(i) != 0)
      abs2model_ptr->set(i, i, quad_model.get_linear(i));
  }
  for (qbpp::vindex_t i = 0; i < var_count(); i++) {
    for (qbpp::vindex_t j = 0; j < quad_model.get_degree(i); j++) {
      auto [k, coeff] = quad_model.get_quadratic(i, j);
      abs2model_ptr->set(i, k, coeff);
    }
  }
}
 
//===============================
// Class Solver member functions
//===============================
 
// Execute ABS2 for "quad_model" with "param" and returns "sol".
inline Sol Solver::operator()(const QuadModel &quad_model, Param &param) const {
  // target_energy is adjusted by the constant term of the QUBO model because
  // ABS2 Solver does not handle constant terms.
  if (param.get_target_energy().has_value()) {
    param.set("target_energy",
              std::to_string(param.get_target_energy().value() -
                             quad_model.get_constant()));
  }
  return Sol(quad_model,
             abs2::Solver::operator()(quad_model.get_abs2_model(), param));
}
 
// Execute ABS2 for model with "quad_param" and "start", and returns "sol".
inline Sol Solver::operator()(const QuadModel &quad_model, Param &param,
                              const Sol &start) const {
  // target_energy is adjusted by the constant term of the QUBO model because
  // ABS2 Solver does not handle constant terms.
  if (param.get_target_energy().has_value()) {
    param.set("target_energy",
              std::to_string(param.get_target_energy().value() -
                             quad_model.get_constant()));
  }
  return Sol(quad_model,
             abs2::Solver::operator()(quad_model.get_abs2_model(), param,
                                      *start.get_abs2sol_ptr()));
}
 
//=============================
// Class Sol member functions
//=============================
inline Sol::Sol(const QuadModel &quad_model, const abs2::Sol &sol)
    : qbpp::Sol(quad_model), abs2sol_ptr(std::make_shared<abs2::Sol>(sol)) {
  for (qbpp::vindex_t i = 0; i < quad_model.var_count(); i++) {
    qbpp::Sol::set(i, abs2sol_ptr->get(i));
  }
  energy_ = std::stod(abs2sol_ptr->get("energy")) + quad_model.get_constant();
}
 
inline Sol::Sol(const qbpp::Sol &sol)
    : qbpp::Sol(sol), abs2sol_ptr(std::make_shared<abs2::Sol>(var_count())) {
  for (qbpp::vindex_t i = 0; i < var_count(); i++) {
    abs2sol_ptr->set(i, sol.get(i));
  }
}
 
}  // namespace qbpp_abs2
#endif  // QBPP_ABS2_HPP