MP2NL: solve LP #237

include/mp/backend-to-model-api.h

@@ -17,7 +17,9 @@ class Backend2ModelAPIConnector :
   // Retrieve the other object
   CommonInfo* get_other() { assert(other_); return other_; }
   /// Set the other object.
-  /// This is standardly called from CreateModelManagerWithModelAPI()
+  /// This is standardly called from CreateModelManagerWithModelAPI(),
+  /// thus, after construction of both
+  /// (Solver)Backend and (Solver)ModelAPI.
   void set_other(CommonInfo* other) { other_ = other; }
 
   /// Copy into the other object.

nl-writer2/include/mp/nl-solver.h

@@ -246,7 +246,7 @@ class NLSolver {
   std::unique_ptr<NLHeader> p_nlheader_;
   NLModel::PreprocessData pd_;
 
-  std::string err_msg_;
+  std::string err_msg_ {"Solving not attempted"};    // We don't check if empty
   NLW2_WriteNLResultCode nl_result_
   {NLW2_WriteNL_Unset};
   NLW2_SOLReadResultCode sol_result_

nl-writer2/include/mp/nl-utils.h

@@ -59,7 +59,7 @@ class File {
     f_ = nullptr;
   }
 
-  /// Printf
+  /// Printf into the file
   void Printf(const char* format, ...);
 
   /// Obtain handler

nl-writer2/include/mp/sol-handler.h

@@ -132,6 +132,9 @@ class SOLHandler {
   /**
    * Receive notification of the objective index
    * used by the driver (solver option 'objno'-1).
+   *
+   * @note AMPL .sol file does not provide
+   *   objective values, only in the solve message if at all.
    */
   void OnObjno(int ) { }
 

solvers/mp2nl/mp2nlbackend.cc

@@ -38,6 +38,7 @@ MP2NLBackend::MP2NLBackend() {
   SetMM( std::move( data ) );
   SetValuePresolver(pPre);
 
+  p_nlsi_ = get_other()->p_nlsi_;    // before copying
   /// Copy env/lp to ModelAPI
   copy_common_info_to_other();
 }
@@ -59,23 +60,19 @@ std::string MP2NLBackend::set_external_libs() {
 }
 
 ArrayRef<double> MP2NLBackend::PrimalSolution() {
-  int num_vars = NumVars();
-  std::vector<double> x(num_vars);
-  return x;
+  return GetNLSolver().GetX();
 }
 
 pre::ValueMapDbl MP2NLBackend::DualSolution() {
-  return {{ { CG_Linear, DualSolution_LP() } }};
+  return {{ { CG_Algebraic, DualSolution_LP() } }};
 }
 
 ArrayRef<double> MP2NLBackend::DualSolution_LP() {
-  int num_cons = NumLinCons();
-  std::vector<double> pi(num_cons);
-  return pi;
+  return GetNLSolver().GetY();
 }
 
 double MP2NLBackend::ObjectiveValue() const {
-  return 0.0;
+  return -DBL_MAX/1.01;                        // SOL does not provide one
 }
 
 double MP2NLBackend::NodeCount() const {
@@ -95,10 +92,13 @@ void MP2NLBackend::ExportModel(const std::string &file) {
 
 
 void MP2NLBackend::SetInterrupter(mp::Interrupter *inter) {
+  // TODO
 }
 
 void MP2NLBackend::Solve() {
-  // TODO
+  GetNLSolver().Solve(
+      storedOptions_.solver_.c_str(),
+      storedOptions_.solver_options_.c_str());
   WindupMP2NLSolve();
 }
 
@@ -141,16 +141,12 @@ void MP2NLBackend::ReportMP2NLPool() {
 
 
 void MP2NLBackend::AddMP2NLMessages() {
-  AddToSolverMessage(
-          fmt::format("{} simplex iterations\n", SimplexIterations()));
-  if (auto nbi = BarrierIterations())
-    AddToSolverMessage(
-          fmt::format("{} barrier iterations\n", nbi));
 }
 
 std::pair<int, std::string> MP2NLBackend::GetSolveResult() {
-  namespace sol = mp::sol;
-  return { sol::UNKNOWN, "not solved" };
+  return {
+          GetNLSolver().GetSolveResult(),
+      GetNLSolver().GetSolveMessage() };
 }
 
 
@@ -182,21 +178,31 @@ void MP2NLBackend::InitCustomOptions() {
     "To set these options, assign a string specifying their values to the "
     "AMPL option ``mp2nl_options``. For example::\n"
     "\n"
-    "  ampl: option mp2nl_options 'mipgap=1e-6';\n");
+    "  ampl: option mp2nl_options 'solver=baron solver_options=\"outlev=1 iisfind=1\"';\n");
 
   AddStoredOption("tech:outlev outlev",
-    "0*/1: Whether to write MP2NL log lines (chatter) to stdout and to file.",
+    "0*/1: Verbosity for the MP2NL driver. For the underlying solver, use tech:solver_options.",
     storedOptions_.outlev_);
 
-  AddStoredOption("tech:logfile logfile",
-    "Log file name.",
-    storedOptions_.logFile_);
+  // AddStoredOption("tech:logfile logfile",
+  //                 "Log file name.",
+  //                 storedOptions_.logFile_);
+
+  AddStoredOption("tech:solver solver",
+                  "Underlying AMPL solver.",
+                  storedOptions_.solver_);
+
+  AddStoredOption("tech:solver_options solver_options slv_opts",
+                  "Underlying solver options.",
+                  storedOptions_.solver_options_);
 
+  /// Enforce time limit?
   // AddSolverOption("lim:time timelim timelimit time_limit",
   //   "Limit on solve time (in seconds; default: 1e+20).",
   //   "limits/time", 0.0, 1e+20);
 
 
+  /// Custom infinity value?
   // AddSolverOption("num:infinity infinity",
   //   "Values larger than this are considered infinity (default: 1e+20)",
   //   "numerics/infinity", 1e+10, DBL_MAX);

solvers/mp2nl/mp2nlbackend.h

@@ -56,7 +56,7 @@ class MP2NLBackend :
  * MULTISOL support
  * No API, see ReportIntermediateSolution()
 **/
-  ALLOW_STD_FEATURE(MULTISOL, true)
+  ALLOW_STD_FEATURE(MULTISOL, false)
 
   /**
   * Get/Set AMPL var/con statii
@@ -84,7 +84,7 @@ class MP2NLBackend :
   /**
   * EXPORT PROBLEM
   **/
-  ALLOW_STD_FEATURE(WRITE_PROBLEM, true)
+  ALLOW_STD_FEATURE(WRITE_PROBLEM, false)
   void DoWriteProblem(const std::string& name) override;
 
 
@@ -93,15 +93,15 @@ class MP2NLBackend :
   **/
   // return MIP gap
   // (adds option mip:return_gap)
-  ALLOW_STD_FEATURE(RETURN_MIP_GAP, true)
+  ALLOW_STD_FEATURE(RETURN_MIP_GAP, false)
   double MIPGap() override;
   double MIPGapAbs() override;
   /**
   * Get MIP dual bound
   **/
   // return the best dual bound value
   // (adds option mip:bestbound)
-  ALLOW_STD_FEATURE(RETURN_BEST_DUAL_BOUND, true)
+  ALLOW_STD_FEATURE(RETURN_BEST_DUAL_BOUND, false)
   double BestDualBound() override;
 
   /////////////////////////// Model attributes /////////////////////////
@@ -162,11 +162,10 @@ class MP2NLBackend :
 private:
   /// These options are stored in the class
   struct Options {
-    std::string logFile_, paramRead_;
-    int concurrent_ = 0;
-    int heuristics_ = 0;
-    int cuts_ = 0;
-    int presolvings_ = 0;
+    std::string solver_,
+        solver_options_;
+    std::string logFile_,
+        nlstub_;
     int outlev_ = 0;
   };
   Options storedOptions_;

solvers/mp2nl/mp2nlcommon.h

@@ -4,17 +4,96 @@
 #include <vector>
 #include <string>
 
+#include "mp/arrayref.h"
 #include "mp/backend-to-model-api.h"
 
 #include "mp/format.h"
 
 
 namespace mp {
 
+
+/// interface for quesry callbacks
+class MP2NLSolverQueryCallbacks {
+public:
+  /// Virtual destruct
+  virtual ~MP2NLSolverQueryCallbacks() { }
+
+  /// ...
+};
+
+
+/// MP2NLSolverNLParams
+struct MP2NLSolverNLParams {
+  /// NL format text mode?
+  int if_nl_text_ {};
+  /// In text mode, comments?
+  int if_nl_comments_ {};
+  /// Custom stub file?
+  const char* stub_file_ {};
+};
+
+
+/// Interface for NLSolver
+class MP2NLSolverIntf {
+public:
+  /// Virtual destruct
+  virtual ~MP2NLSolverIntf() { }
+
+  /// Provide query callback (e.g., for suffixes)
+  void ProvideQuaryCallbacks(MP2NLSolverQueryCallbacks& qc)
+  { p_nlsq_ = &qc; }
+
+  void ProvideNLParams(MP2NLSolverNLParams prm) { prm_ = prm; }
+
+  /// Solve
+  virtual void Solve(const char* solver, const char* sopts) = 0;
+
+  /// AMPL solve result code
+  virtual int GetSolveResult() const = 0;
+
+  /// Solve result message or error message
+  virtual const char* GetSolveMessage() const = 0;
+
+  /// Number of backspaces to print
+  /// if printing the solve message right here,
+  /// or skip so many symbols first.
+  virtual int GetSolveMessageNbs() const = 0;
+
+  /// Stub file used
+  virtual const char* GetFileStub() const = 0;
+
+  /// Objno used.
+  /// @note AMPL .sol file does not provide
+  ///   objective values, only in the solve message if at all.
+  virtual int GetObjnoUsed() const = 0;
+
+  /// Primal solution
+  virtual ArrayRef<double> GetX() const = 0;
+
+  /// Dual solution
+  virtual ArrayRef<double> GetY() const = 0;
+
+  /// @todo + Suffixes... Pull or push?
+  /// ..
+protected:
+  MP2NLSolverQueryCallbacks* GetCallbacks()
+  { assert(p_nlsq_); return p_nlsq_; }
+  const MP2NLSolverNLParams& GetParams() const { return prm_; }
+  MP2NLSolverNLParams& GetParams() { return prm_; }
+private:
+  MP2NLSolverQueryCallbacks* p_nlsq_ {};
+  MP2NLSolverNLParams prm_ {};
+};
+
+
 /// Information shared by both
-/// `ScipBackend` and `ScipModelAPI`
+/// `MP2NLBackend` and `MP2NLModelAPI`
 struct MP2NLCommonInfo {
-
+  /// MP2NLSolver
+  MP2NLSolverIntf* p_nlsi_ {};
+  /// Query cb
+  MP2NLSolverQueryCallbacks* p_qc_ {};
 private:
 };
 
@@ -30,6 +109,11 @@ class MP2NLCommon :
   void OpenSolver();
   void CloseSolver();
 
+  const MP2NLSolverIntf& GetNLSolver() const
+  { assert(p_nlsi_); return *p_nlsi_; }
+  MP2NLSolverIntf& GetNLSolver()
+  { assert(p_nlsi_); return *p_nlsi_; }
+
   int NumLinCons() const;
   int NumVars() const;
   int NumObjs() const;