27#include "absl/log/log.h"
28#include "absl/memory/memory.h"
29#include "absl/status/status.h"
30#include "absl/status/statusor.h"
31#include "absl/strings/str_cat.h"
32#include "absl/strings/str_join.h"
33#include "absl/strings/str_split.h"
34#include "absl/strings/string_view.h"
35#include "absl/time/time.h"
63using pdlp::PrimalAndDualSolution;
64using pdlp::PrimalDualHybridGradientParams;
65using pdlp::SolverResult;
72 auto result = absl::WrapUnique(
new PdlpSolver);
80 std::vector<std::string> warnings;
89 absl::ToDoubleSeconds(
93 warnings.push_back(
"parameter node_limit not supported for PDLP");
96 warnings.push_back(
"parameter cutoff_limit not supported for PDLP");
99 warnings.push_back(
"parameter best_objective_limit not supported for PDLP");
102 warnings.push_back(
"parameter best_bound_limit not supported for PDLP");
105 warnings.push_back(
"parameter solution_limit not supported for PDLP");
108 warnings.push_back(
"parameter random_seed not supported for PDLP");
112 warnings.push_back(
"parameter lp_algorithm not supported for PDLP");
115 warnings.push_back(
"parameter presolve not supported for PDLP");
118 warnings.push_back(
"parameter cuts not supported for PDLP");
121 warnings.push_back(
"parameter heuristics not supported for PDLP");
124 warnings.push_back(
"parameter scaling not supported for PDLP");
127 const int64_t limit = std::min<int64_t>(std::numeric_limits<int32_t>::max(),
130 static_cast<int32_t
>(limit));
133 if (!warnings.empty()) {
134 return absl::InvalidArgumentError(absl::StrJoin(warnings,
"; "));
141absl::StatusOr<TerminationProto> ConvertReason(
143 const bool is_maximize,
const double primal_objective,
144 const double dual_objective) {
145 switch (pdlp_reason) {
149 absl::StrCat(
"PDLP unspecified reason "
150 "(TERMINATION_REASON_UNSPECIFIED): ",
170 std::nullopt, pdlp_detail);
174 std::nullopt, pdlp_detail);
178 std::nullopt, pdlp_detail);
185 std::nullopt, pdlp_detail);
189 return absl::InternalError(
190 absl::StrCat(
"Invalid problem sent to PDLP solver "
191 "(TERMINATION_REASON_INVALID_PROBLEM): ",
194 return absl::InvalidArgumentError(
195 absl::StrCat(
"PDLP solution hint invalid "
196 "(TERMINATION_REASON_INVALID_INITIAL_SOLUTION): ",
200 return absl::InvalidArgumentError(absl::StrCat(
201 "PDLP parameters invalid (TERMINATION_REASON_INVALID_PARAMETER): ",
212 return absl::InvalidArgumentError(absl::StrCat(
218absl::StatusOr<SolveResultProto> PdlpSolver::MakeSolveResult(
219 const pdlp::SolverResult& pdlp_result,
224 const double objective_scaling_factor =
225 pdlp_bridge_.pdlp_lp().objective_scaling_factor;
226 const bool is_maximize = objective_scaling_factor < 0.0;
227 SolveResultProto result;
228 const std::optional<pdlp::ConvergenceInformation> convergence_information =
230 pdlp_result.solve_log.solution_type());
231 if (convergence_information.has_value()) {
232 *result.mutable_pdlp_output()->mutable_convergence_information() =
233 *convergence_information;
236 if (convergence_information.has_value()) {
237 objective_bounds.set_primal_bound(
238 convergence_information->primal_objective());
239 objective_bounds.set_dual_bound(convergence_information->dual_objective());
242 ConvertReason(pdlp_result.solve_log.termination_reason(),
243 pdlp_result.solve_log.termination_string(),
244 is_maximize, objective_bounds.primal_bound(),
245 objective_bounds.dual_bound()));
248 absl::Seconds(pdlp_result.solve_log.solve_time_sec())));
249 result.mutable_solve_stats()->set_first_order_iterations(
250 pdlp_result.solve_log.iteration_count());
252 switch (pdlp_result.solve_log.termination_reason()) {
259 SolutionProto* solution_proto = result.add_solutions();
261 auto maybe_primal = pdlp_bridge_.PrimalVariablesToProto(
262 pdlp_result.primal_solution, model_params.variable_values_filter());
264 PrimalSolutionProto* primal_proto =
265 solution_proto->mutable_primal_solution();
267 *primal_proto->mutable_variable_values() = *std::move(maybe_primal);
272 if (pdlp_result.solve_log.termination_reason() ==
276 if (convergence_information.has_value()) {
277 primal_proto->set_objective_value(
278 convergence_information->primal_objective());
282 auto maybe_dual = pdlp_bridge_.DualVariablesToProto(
283 pdlp_result.dual_solution, model_params.dual_values_filter());
285 auto maybe_reduced = pdlp_bridge_.ReducedCostsToProto(
286 pdlp_result.reduced_costs, model_params.reduced_costs_filter());
288 DualSolutionProto* dual_proto = solution_proto->mutable_dual_solution();
290 *dual_proto->mutable_dual_values() = *std::move(maybe_dual);
291 *dual_proto->mutable_reduced_costs() = *std::move(maybe_reduced);
293 if (pdlp_result.solve_log.termination_reason() ==
297 if (convergence_information.has_value()) {
298 dual_proto->set_objective_value(
299 convergence_information->dual_objective());
307 auto maybe_dual = pdlp_bridge_.DualVariablesToProto(
308 pdlp_result.dual_solution, model_params.dual_values_filter());
310 auto maybe_reduced = pdlp_bridge_.ReducedCostsToProto(
311 pdlp_result.reduced_costs, model_params.reduced_costs_filter());
313 DualRayProto* dual_ray_proto = result.add_dual_rays();
314 *dual_ray_proto->mutable_dual_values() = *std::move(maybe_dual);
315 *dual_ray_proto->mutable_reduced_costs() = *std::move(maybe_reduced);
321 auto maybe_primal = pdlp_bridge_.PrimalVariablesToProto(
322 pdlp_result.primal_solution, model_params.variable_values_filter());
324 PrimalRayProto* primal_ray_proto = result.add_primal_rays();
325 *primal_ray_proto->mutable_variable_values() = *std::move(maybe_primal);
348 message_cb !=
nullptr));
354 std::atomic<bool> interrupt =
false;
356 interrupter, [&]() { interrupt =
true; });
358 std::optional<PrimalAndDualSolution> initial_solution;
360 initial_solution = pdlp_bridge_.SolutionHintToWarmStart(
364 std::function<void(
const std::string&)> pdlp_callback =
nullptr;
365 if (message_cb !=
nullptr) {
366 pdlp_callback = [&message_cb](
const std::string& message) {
367 message_cb(absl::StrSplit(message,
'\n'));
372 PrimalDualHybridGradient(pdlp_bridge_.pdlp_lp(), pdlp_params,
373 initial_solution, &interrupt, pdlp_callback);
374 return MakeSolveResult(pdlp_result, model_parameters);
381absl::StatusOr<ComputeInfeasibleSubsystemResultProto>
385 return absl::UnimplementedError(
386 "PDLP does not provide a method to compute an infeasible subsystem");
#define ASSIGN_OR_RETURN(lhs, rexpr)
#define RETURN_IF_ERROR(expr)
const ::operations_research::math_opt::SolutionHintProto & solution_hints(int index) const
static absl::StatusOr< PdlpBridge > FromProto(const ModelProto &model_proto)
static absl::StatusOr< std::unique_ptr< SolverInterface > > New(const ModelProto &model, const InitArgs &init_args)
absl::StatusOr< ComputeInfeasibleSubsystemResultProto > ComputeInfeasibleSubsystem(const SolveParametersProto ¶meters, MessageCallback message_cb, const SolveInterrupter *interrupter) override
absl::StatusOr< SolveResultProto > Solve(const SolveParametersProto ¶meters, const ModelSolveParametersProto &model_parameters, MessageCallback message_cb, const CallbackRegistrationProto &callback_registration, Callback cb, const SolveInterrupter *interrupter) override
static absl::StatusOr< pdlp::PrimalDualHybridGradientParams > MergeParameters(const SolveParametersProto ¶meters, bool has_message_callback)
Returns the merged parameters and a list of warnings.
absl::StatusOr< bool > Update(const ModelUpdateProto &model_update) override
::operations_research::math_opt::EmphasisProto presolve() const
bool has_cutoff_limit() const
optional double cutoff_limit = 20;
::int32_t threads() const
bool has_objective_limit() const
optional double objective_limit = 21;
bool has_random_seed() const
optional int32 random_seed = 5;
bool has_solution_limit() const
optional int32 solution_limit = 23;
::operations_research::math_opt::EmphasisProto scaling() const
::operations_research::math_opt::EmphasisProto heuristics() const
bool has_node_limit() const
optional int64 node_limit = 24;
bool enable_output() const
::operations_research::math_opt::LPAlgorithmProto lp_algorithm() const
const ::operations_research::pdlp::PrimalDualHybridGradientParams & pdlp() const
::int64_t iteration_limit() const
bool has_best_bound_limit() const
optional double best_bound_limit = 22;
bool has_threads() const
optional int32 threads = 4;
const ::google::protobuf::Duration & time_limit() const
bool has_time_limit() const
.google.protobuf.Duration time_limit = 1;
bool has_iteration_limit() const
optional int64 iteration_limit = 2;
::operations_research::math_opt::EmphasisProto cuts() const
std::function< void(const std::vector< std::string > &)> MessageCallback
std::function< absl::StatusOr< CallbackResultProto >( const CallbackDataProto &)> Callback
::operations_research::pdlp::TerminationCriteria *PROTOBUF_NONNULL mutable_termination_criteria()
void set_num_threads(::int32_t value)
void MergeFrom(const PrimalDualHybridGradientParams &from)
void set_verbosity_level(::int32_t value)
void set_time_sec_limit(double value)
void set_iteration_limit(::int32_t value)
An object oriented wrapper for quadratic constraints in ModelStorage.
TerminationProto TerminateForReason(const TerminationReasonProto reason, const absl::string_view detail)
@ TERMINATION_REASON_OTHER_ERROR
@ TERMINATION_REASON_NUMERICAL_ERROR
@ TERMINATION_REASON_UNSPECIFIED
absl::Status ModelSolveParametersAreSupported(const ModelSolveParametersProto &model_parameters, const SupportedProblemStructures &support_menu, const absl::string_view solver_name)
@ SOLUTION_STATUS_UNDETERMINED
@ SOLUTION_STATUS_FEASIBLE
@ LP_ALGORITHM_FIRST_ORDER
@ LP_ALGORITHM_UNSPECIFIED
TerminationProto OptimalTerminationProto(const double finite_primal_objective, const double dual_objective, const absl::string_view detail)
@ FEASIBILITY_STATUS_UNDETERMINED
@ FEASIBILITY_STATUS_INFEASIBLE
TerminationProto InfeasibleOrUnboundedTerminationProto(bool is_maximize, const FeasibilityStatusProto dual_feasibility_status, const absl::string_view detail)
TerminationProto NoSolutionFoundTerminationProto(const bool is_maximize, const LimitProto limit, const std::optional< double > optional_dual_objective, const absl::string_view detail)
absl::Status CheckRegisteredCallbackEvents(const CallbackRegistrationProto ®istration, const absl::flat_hash_set< CallbackEventProto > &supported_events)
constexpr SupportedProblemStructures kPdlpSupportedStructures
TerminationProto InfeasibleTerminationProto(bool is_maximize, const FeasibilityStatusProto dual_feasibility_status, const absl::string_view detail)
ObjectiveBoundsProto MakeTrivialBounds(const bool is_maximize)
std::optional< ConvergenceInformation > GetConvergenceInformation(const IterationStats &stats, PointType candidate_type)
@ TERMINATION_REASON_DUAL_INFEASIBLE
@ TERMINATION_REASON_TIME_LIMIT
@ TERMINATION_REASON_KKT_MATRIX_PASS_LIMIT
@ TERMINATION_REASON_PRIMAL_OR_DUAL_INFEASIBLE
@ TERMINATION_REASON_INVALID_PROBLEM
@ TERMINATION_REASON_PRIMAL_INFEASIBLE
@ TERMINATION_REASON_OPTIMAL
@ TERMINATION_REASON_ITERATION_LIMIT
@ TERMINATION_REASON_INVALID_INITIAL_SOLUTION
@ TERMINATION_REASON_UNSPECIFIED
@ TERMINATION_REASON_INVALID_PARAMETER
@ TERMINATION_REASON_NUMERICAL_ERROR
@ TERMINATION_REASON_OTHER
@ TERMINATION_REASON_INTERRUPTED_BY_USER
In SWIG mode, we don't want anything besides these top-level includes.
std::string ProtoEnumToString(ProtoEnumType enum_value)
inline ::absl::StatusOr< absl::Duration > DecodeGoogleApiProto(const google::protobuf::Duration &proto)
inline ::absl::StatusOr< google::protobuf::Duration > EncodeGoogleApiProto(absl::Duration d)
#define MATH_OPT_REGISTER_SOLVER(solver_type, solver_factory)
Initialization arguments.