18#include "absl/container/flat_hash_set.h"
19#include "absl/status/statusor.h"
20#include "absl/strings/str_cat.h"
28#include "scip/cons_linear.h"
29#include "scip/scip_general.h"
30#include "scip/scip_param.h"
31#include "scip/scip_solvingstats.h"
32#include "scip/scipdefplugins.h"
33#include "scip/type_cons.h"
37#define RETURN_ERROR_UNLESS(x) \
39 return util::StatusBuilder(absl::InvalidArgumentError(absl::StrFormat( \
40 "Condition violated at %s:%d: %s", __FILE__, __LINE__, #x)))
44constexpr absl::string_view kLinearConstraintHandlerName =
"linear";
46SCIP_VARTYPE ConvertVarType(
const GScipVarType var_type) {
49 return SCIP_VARTYPE_CONTINUOUS;
51 return SCIP_VARTYPE_IMPLINT;
53 return SCIP_VARTYPE_INTEGER;
57GScipVarType ConvertVarType(
const SCIP_VARTYPE var_type) {
59 case SCIP_VARTYPE_CONTINUOUS:
61 case SCIP_VARTYPE_IMPLINT:
63 case SCIP_VARTYPE_INTEGER:
64 case SCIP_VARTYPE_BINARY:
69GScipOutput::Status ConvertStatus(
const SCIP_STATUS scip_status) {
70 switch (scip_status) {
71 case SCIP_STATUS_UNKNOWN:
72 return GScipOutput::UNKNOWN;
73 case SCIP_STATUS_USERINTERRUPT:
74 return GScipOutput::USER_INTERRUPT;
75 case SCIP_STATUS_BESTSOLLIMIT:
76 return GScipOutput::BEST_SOL_LIMIT;
77 case SCIP_STATUS_MEMLIMIT:
78 return GScipOutput::MEM_LIMIT;
79 case SCIP_STATUS_NODELIMIT:
80 return GScipOutput::NODE_LIMIT;
81 case SCIP_STATUS_RESTARTLIMIT:
82 return GScipOutput::RESTART_LIMIT;
83 case SCIP_STATUS_SOLLIMIT:
84 return GScipOutput::SOL_LIMIT;
85 case SCIP_STATUS_STALLNODELIMIT:
86 return GScipOutput::STALL_NODE_LIMIT;
87 case SCIP_STATUS_TIMELIMIT:
88 return GScipOutput::TIME_LIMIT;
89 case SCIP_STATUS_TOTALNODELIMIT:
90 return GScipOutput::TOTAL_NODE_LIMIT;
91 case SCIP_STATUS_OPTIMAL:
92 return GScipOutput::OPTIMAL;
93 case SCIP_STATUS_GAPLIMIT:
94 return GScipOutput::GAP_LIMIT;
95 case SCIP_STATUS_INFEASIBLE:
96 return GScipOutput::INFEASIBLE;
97 case SCIP_STATUS_UNBOUNDED:
98 return GScipOutput::UNBOUNDED;
99 case SCIP_STATUS_INFORUNBD:
100 return GScipOutput::INF_OR_UNBD;
101 case SCIP_STATUS_TERMINATE:
102 return GScipOutput::TERMINATE;
104 LOG(
FATAL) <<
"Unrecognized scip status: " << scip_status;
108SCIP_PARAMEMPHASIS ConvertEmphasis(
109 const GScipParameters::Emphasis gscip_emphasis) {
110 switch (gscip_emphasis) {
111 case GScipParameters::DEFAULT_EMPHASIS:
112 return SCIP_PARAMEMPHASIS_DEFAULT;
113 case GScipParameters::CP_SOLVER:
114 return SCIP_PARAMEMPHASIS_CPSOLVER;
115 case GScipParameters::EASY_CIP:
116 return SCIP_PARAMEMPHASIS_EASYCIP;
117 case GScipParameters::FEASIBILITY:
118 return SCIP_PARAMEMPHASIS_FEASIBILITY;
119 case GScipParameters::HARD_LP:
120 return SCIP_PARAMEMPHASIS_HARDLP;
121 case GScipParameters::OPTIMALITY:
122 return SCIP_PARAMEMPHASIS_OPTIMALITY;
124 return SCIP_PARAMEMPHASIS_COUNTER;
125 case GScipParameters::PHASE_FEAS:
126 return SCIP_PARAMEMPHASIS_PHASEFEAS;
127 case GScipParameters::PHASE_IMPROVE:
128 return SCIP_PARAMEMPHASIS_PHASEIMPROVE;
129 case GScipParameters::PHASE_PROOF:
130 return SCIP_PARAMEMPHASIS_PHASEPROOF;
132 LOG(
FATAL) <<
"Unrecognized gscip_emphasis: "
137SCIP_PARAMSETTING ConvertMetaParamValue(
138 const GScipParameters::MetaParamValue gscip_meta_param_value) {
139 switch (gscip_meta_param_value) {
140 case GScipParameters::DEFAULT_META_PARAM_VALUE:
141 return SCIP_PARAMSETTING_DEFAULT;
142 case GScipParameters::AGGRESSIVE:
143 return SCIP_PARAMSETTING_AGGRESSIVE;
144 case GScipParameters::FAST:
145 return SCIP_PARAMSETTING_FAST;
146 case GScipParameters::OFF:
147 return SCIP_PARAMSETTING_OFF;
149 LOG(
FATAL) <<
"Unrecognized gscip_meta_param_value: "
162 return constraint_options;
165absl::Status GScip::SetParams(
const GScipParameters& params,
166 const std::string& legacy_params) {
167 if (params.has_silence_output()) {
168 SCIPsetMessagehdlrQuiet(scip_, params.silence_output());
170 if (!params.search_logs_filename().empty()) {
171 SCIPsetMessagehdlrLogfile(scip_, params.search_logs_filename().c_str());
173 const SCIP_Bool set_param_quiet =
174 static_cast<SCIP_Bool
>(!params.silence_output());
177 scip_, ConvertEmphasis(params.emphasis()), set_param_quiet));
178 if (params.has_heuristics()) {
180 scip_, ConvertMetaParamValue(params.heuristics()), set_param_quiet));
182 if (params.has_presolve()) {
184 scip_, ConvertMetaParamValue(params.presolve()), set_param_quiet));
186 if (params.has_separating()) {
188 scip_, ConvertMetaParamValue(params.separating()), set_param_quiet));
190 for (
const auto& bool_param : params.bool_params()) {
192 (SCIPsetBoolParam(scip_, bool_param.first.c_str(), bool_param.second)));
194 for (
const auto& int_param : params.int_params()) {
196 (SCIPsetIntParam(scip_, int_param.first.c_str(), int_param.second)));
198 for (
const auto& long_param : params.long_params()) {
200 long_param.second)));
202 for (
const auto& char_param : params.char_params()) {
203 if (char_param.second.size() != 1) {
204 return absl::InvalidArgumentError(
205 absl::StrCat(
"Character parameters must be single character strings, "
207 char_param.first,
" was: ", char_param.second));
210 char_param.second[0])));
212 for (
const auto& string_param : params.string_params()) {
214 string_param.second.c_str())));
216 for (
const auto& real_param : params.real_params()) {
218 (SCIPsetRealParam(scip_, real_param.first.c_str(), real_param.second)));
220 if (!legacy_params.empty()) {
224 return absl::OkStatus();
228 const std::string& problem_name) {
229 SCIP*
scip =
nullptr;
234 return absl::WrapUnique(
new GScip(
scip));
237GScip::GScip(SCIP* scip) : scip_(scip) {}
241absl::Status GScip::FreeTransform() {
246 return absl::StrFormat(
"SCIP %d.%d.%d [LP solver: %s]", SCIPmajorVersion(),
247 SCIPminorVersion(), SCIPtechVersion(),
248 SCIPlpiGetSolverName());
252 if (scip_ ==
nullptr) {
255 return SCIPinterruptSolve(scip_) == SCIP_OKAY;
258absl::Status GScip::CleanUp() {
259 if (scip_ !=
nullptr) {
260 for (SCIP_VAR* variable : variables_) {
261 if (variable !=
nullptr) {
265 for (SCIP_CONS* constraint : constraints_) {
266 if (constraint !=
nullptr) {
272 return absl::OkStatus();
276 const absl::Status clean_up_status = CleanUp();
277 LOG_IF(DFATAL, !clean_up_status.ok()) << clean_up_status;
281 double lb,
double ub,
double obj_coef,
GScipVarType var_type,
283 SCIP_VAR*
var =
nullptr;
284 lb = ScipInfClamp(lb);
285 ub = ScipInfClamp(ub);
290 ConvertVarType(var_type)));
295 variables_.insert(
var);
302absl::Status GScip::MaybeKeepConstraintAlive(
305 constraints_.insert(constraint);
309 return absl::OkStatus();
315 SCIP_CONS* constraint =
nullptr;
317 <<
"Error adding constraint: " <<
name <<
".";
320 const_cast<SCIP_VAR**
>(range.
variables.data()),
341 SCIP_CONS* constraint =
nullptr;
344 <<
"Error adding quadratic constraint: " <<
name <<
" in linear term.";
347 <<
"Error adding quadratic constraint: " <<
name <<
" in quadratic term.";
349 <<
"Error adding quadratic constraint: " <<
name <<
" in quadratic term.";
351 scip_, &constraint,
name.c_str(), num_lin_vars,
377 <<
"Error adding indicator constraint: " <<
name <<
".";
382 SCIP_CONS* constraint =
nullptr;
385 <<
"Error adding indicator constraint: " <<
name <<
".";
387 scip_, &constraint,
name.c_str(), indicator,
389 const_cast<SCIP_Var**
>(indicator_constraint.
variables.data()),
390 const_cast<double*
>(indicator_constraint.
coefficients.data()),
410 <<
"Error adding and constraint: " <<
name <<
".";
411 SCIP_CONS* constraint =
nullptr;
413 SCIPcreateConsAnd(scip_, &constraint,
name.c_str(),
415 const_cast<SCIP_VAR**
>(logical_data.
operators.data()),
435 <<
"Error adding or constraint: " <<
name <<
".";
436 SCIP_CONS* constraint =
nullptr;
438 SCIPcreateConsOr(scip_, &constraint,
name.c_str(), logical_data.
resultant,
440 const_cast<SCIP_Var**
>(logical_data.
operators.data()),
458absl::Status ValidateSOSData(
const GScipSOSData& sos_data,
459 const std::string&
name) {
461 <<
"Error adding SOS constraint: " <<
name <<
".";
462 if (!sos_data.
weights.empty()) {
464 <<
" Error adding SOS constraint: " <<
name <<
".";
466 absl::flat_hash_set<double> distinct_weights;
467 for (
const double w : sos_data.
weights) {
469 <<
"Error adding SOS constraint: " <<
name
470 <<
", weights must be distinct, but found value " << w <<
" twice.";
471 distinct_weights.insert(w);
473 return absl::OkStatus();
482 SCIP_CONS* constraint =
nullptr;
483 double* weights =
nullptr;
484 if (!sos_data.
weights.empty()) {
485 weights =
const_cast<double*
>(sos_data.
weights.data());
490 const_cast<SCIP_Var**
>(sos_data.
variables.data()), weights,
509 SCIP_CONS* constraint =
nullptr;
510 double* weights =
nullptr;
511 if (!sos_data.
weights.empty()) {
512 weights =
const_cast<double*
>(sos_data.
weights.data());
516 const_cast<SCIP_Var**
>(sos_data.
variables.data()), weights,
533 scip_, is_maximize ? SCIP_OBJSENSE_MAXIMIZE : SCIP_OBJSENSE_MINIMIZE));
534 return absl::OkStatus();
538 double old_offset = SCIPgetOrigObjoffset(scip_);
539 double delta_offset = offset - old_offset;
541 return absl::OkStatus();
545 return SCIPgetObjsense(scip_) == SCIP_OBJSENSE_MAXIMIZE;
552 return absl::OkStatus();
556 lb = ScipInfClamp(lb);
558 return absl::OkStatus();
562 ub = ScipInfClamp(ub);
564 return absl::OkStatus();
569 return absl::OkStatus();
573 SCIP_Bool infeasible;
575 SCIPchgVarType(scip_,
var, ConvertVarType(var_type), &infeasible));
576 return absl::OkStatus();
580 SCIP_Bool did_delete;
583 <<
"Failed to delete variable named: " <<
Name(
var);
584 variables_.erase(
var);
586 return absl::OkStatus();
590 const absl::flat_hash_set<SCIP_VAR*>& vars) {
591 for (SCIP_CONS* constraint : constraints_) {
593 return absl::InvalidArgumentError(absl::StrCat(
594 "Model contains nonlinear constraint: ",
Name(constraint)));
597 return absl::OkStatus();
603 for (SCIP_CONS* constraint : constraints_) {
604 const absl::Span<SCIP_VAR* const> nonzeros =
606 const std::vector<SCIP_VAR*> nonzeros_copy(nonzeros.begin(),
608 for (SCIP_VAR*
var : nonzeros_copy) {
609 if (vars.contains(
var)) {
614 for (SCIP_VAR*
const var : vars) {
617 return absl::OkStatus();
621 return ScipInfUnclamp(SCIPvarGetLbOriginal(
var));
625 return ScipInfUnclamp(SCIPvarGetUbOriginal(
var));
631 return ConvertVarType(SCIPvarGetType(
var));
637 return absl::string_view(SCIPconshdlrGetName(SCIPconsGetHdlr(constraint)));
641 return ConstraintType(constraint) == kLinearConstraintHandlerName;
645 SCIP_CONS* constraint) {
646 int num_vars = SCIPgetNVarsLinear(scip_, constraint);
647 return absl::MakeConstSpan(SCIPgetValsLinear(scip_, constraint), num_vars);
651 SCIP_CONS* constraint) {
652 int num_vars = SCIPgetNVarsLinear(scip_, constraint);
653 return absl::MakeConstSpan(SCIPgetVarsLinear(scip_, constraint), num_vars);
657 return ScipInfUnclamp(SCIPgetLhsLinear(scip_, constraint));
661 return ScipInfUnclamp(SCIPgetRhsLinear(scip_, constraint));
665 return SCIPconsGetName(constraint);
669 lb = ScipInfClamp(lb);
671 return absl::OkStatus();
675 ub = ScipInfClamp(ub);
677 return absl::OkStatus();
682 constraints_.erase(constraint);
684 return absl::OkStatus();
693 return absl::OkStatus();
699 const int scip_num_vars = SCIPgetNOrigVars(scip_);
700 const bool is_solution_partial = partial_solution.size() < scip_num_vars;
701 if (is_solution_partial) {
706 <<
"Error suggesting hint.";
709 for (
const auto& var_value_pair : partial_solution) {
711 var_value_pair.second));
713 if (!is_solution_partial) {
714 SCIP_Bool is_feasible;
716 scip_, solution,
false,
true,
719 if (!
static_cast<bool>(is_feasible)) {
726 if (
static_cast<bool>(is_stored)) {
734 const std::string& legacy_params) {
744 const absl::Status param_status = SetParams(params, legacy_params);
745 if (!param_status.ok()) {
746 result.
gscip_output.set_status(GScipOutput::INVALID_SOLVER_PARAMETERS);
749 std::string(param_status.message()));
752 if (params.print_scip_model()) {
755 if (!params.scip_model_filename().empty()) {
757 scip_, params.scip_model_filename().c_str(),
"cip", FALSE));
768 const SCIP_STAGE stage = SCIPgetStage(scip_);
769 if (stage != SCIP_STAGE_PRESOLVING && stage != SCIP_STAGE_SOLVING &&
770 stage != SCIP_STAGE_SOLVED) {
773 absl::StrCat(
"Unpexpected SCIP final stage= ", stage,
774 " was expected to be either SCIP_STAGE_PRESOLVING, "
775 "SCIP_STAGE_SOLVING, or SCIP_STAGE_SOLVED"));
778 if (params.print_detailed_solving_stats()) {
781 if (!params.detailed_solving_stats_filename().empty()) {
782 FILE*
file = fopen(params.detailed_solving_stats_filename().c_str(),
"w");
783 if (
file ==
nullptr) {
784 return absl::InvalidArgumentError(absl::StrCat(
785 "Could not open file: ", params.detailed_solving_stats_filename(),
786 " to write SCIP solve stats."));
789 int close_result = fclose(
file);
790 if (close_result != 0) {
791 return absl::InvalidArgumentError(absl::StrCat(
792 "Error: ", close_result,
793 " closing file: ", params.detailed_solving_stats_filename(),
794 " when writing solve stats."));
800 GScipSolvingStats* stats = result.
gscip_output.mutable_stats();
801 const int num_scip_solutions = SCIPgetNSols(scip_);
802 const int num_returned_solutions =
804 SCIP_SOL** all_solutions = SCIPgetSols(scip_);
805 stats->set_best_objective(ScipInfUnclamp(SCIPgetPrimalbound(scip_)));
806 for (
int i = 0; i < num_returned_solutions; ++i) {
807 SCIP_SOL* scip_sol = all_solutions[i];
808 const double obj_value = ScipInfUnclamp(SCIPgetSolOrigObj(scip_, scip_sol));
810 for (SCIP_VAR* v : variables_) {
811 solution[v] = SCIPgetSolVal(scip_, scip_sol, v);
817 if (stage != SCIP_STAGE_PRESOLVING && SCIPhasPrimalRay(scip_)) {
818 for (SCIP_VAR* v : variables_) {
819 result.
primal_ray[v] = SCIPgetPrimalRayVal(scip_, v);
823 stats->set_best_bound(ScipInfUnclamp(SCIPgetDualbound(scip_)));
824 stats->set_node_count(SCIPgetNTotalNodes(scip_));
825 stats->set_first_lp_relaxation_bound(SCIPgetFirstLPDualboundRoot(scip_));
826 stats->set_root_node_bound(SCIPgetDualboundRoot(scip_));
827 if (stage != SCIP_STAGE_PRESOLVING) {
828 stats->set_total_lp_iterations(SCIPgetNLPIterations(scip_));
829 stats->set_primal_simplex_iterations(SCIPgetNPrimalLPIterations(scip_));
830 stats->set_dual_simplex_iterations(SCIPgetNDualLPIterations(scip_));
831 stats->set_deterministic_time(SCIPgetDeterministicTime(scip_));
833 result.
gscip_output.set_status(ConvertStatus(SCIPgetStatus(scip_)));
842 const std::string& parameter_name) {
843 SCIP_Bool default_value;
845 SCIPgetBoolParam(scip_, parameter_name.c_str(), &default_value));
846 return static_cast<bool>(default_value);
850 const std::string& parameter_name) {
853 SCIPgetIntParam(scip_, parameter_name.c_str(), &default_value));
854 return default_value;
858 const std::string& parameter_name) {
861 SCIPgetLongintParam(scip_, parameter_name.c_str(), &result));
862 return static_cast<int64_t
>(result);
866 const std::string& parameter_name) {
869 SCIPgetRealParam(scip_, parameter_name.c_str(), &result));
874 const std::string& parameter_name) {
877 SCIPgetCharParam(scip_, parameter_name.c_str(), &result));
882 const std::string& parameter_name) {
885 SCIPgetStringParam(scip_, parameter_name.c_str(), &result));
886 return std::string(result);
889double GScip::ScipInfClamp(
double d) {
890 const double kScipInf =
ScipInf();
891 if (d > kScipInf)
return kScipInf;
892 if (d < -kScipInf)
return -kScipInf;
896double GScip::ScipInfUnclamp(
double d) {
897 const double kScipInf =
ScipInf();
898 if (d >= kScipInf)
return std::numeric_limits<double>::infinity();
899 if (d <= -kScipInf)
return -std::numeric_limits<double>::infinity();
903#undef RETURN_ERROR_UNLESS
#define LOG_IF(severity, condition)
double LinearConstraintUb(SCIP_CONS *constraint)
absl::Status SetObjectiveOffset(double offset)
absl::StatusOr< SCIP_VAR * > AddVariable(double lb, double ub, double obj_coef, GScipVarType var_type, const std::string &var_name="", const GScipVariableOptions &options=DefaultGScipVariableOptions())
absl::Status DeleteVariable(SCIP_VAR *var)
absl::StatusOr< SCIP_CONS * > AddOrConstraint(const GScipLogicalConstraintData &logical_data, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
absl::StatusOr< double > DefaultRealParamValue(const std::string ¶meter_name)
absl::Status CanSafeBulkDelete(const absl::flat_hash_set< SCIP_VAR * > &vars)
absl::StatusOr< SCIP_CONS * > AddAndConstraint(const GScipLogicalConstraintData &logical_data, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
absl::StatusOr< SCIP_CONS * > AddLinearConstraint(const GScipLinearRange &range, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
bool IsConstraintLinear(SCIP_CONS *constraint)
absl::string_view ConstraintType(SCIP_CONS *constraint)
absl::StatusOr< int64_t > DefaultLongParamValue(const std::string ¶meter_name)
absl::StatusOr< int > DefaultIntParamValue(const std::string ¶meter_name)
absl::Status DeleteConstraint(SCIP_CONS *constraint)
absl::Status SetLinearConstraintUb(SCIP_CONS *constraint, double ub)
absl::Status SafeBulkDelete(const absl::flat_hash_set< SCIP_VAR * > &vars)
absl::StatusOr< GScipResult > Solve(const GScipParameters ¶ms=GScipParameters(), const std::string &legacy_params="")
static absl::StatusOr< std::unique_ptr< GScip > > Create(const std::string &problem_name)
double ObjCoef(SCIP_VAR *var)
absl::Status SetMaximize(bool is_maximize)
absl::StatusOr< std::string > DefaultStringParamValue(const std::string ¶meter_name)
absl::StatusOr< bool > DefaultBoolParamValue(const std::string ¶meter_name)
absl::StatusOr< SCIP_CONS * > AddIndicatorConstraint(const GScipIndicatorConstraint &indicator_constraint, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
absl::Status SetLb(SCIP_VAR *var, double lb)
absl::Span< SCIP_VAR *const > LinearConstraintVariables(SCIP_CONS *constraint)
double LinearConstraintLb(SCIP_CONS *constraint)
absl::Status SetLinearConstraintCoef(SCIP_CONS *constraint, SCIP_VAR *var, double value)
absl::Status SetLinearConstraintLb(SCIP_CONS *constraint, double lb)
absl::StatusOr< GScipHintResult > SuggestHint(const GScipSolution &partial_solution)
GScipVarType VarType(SCIP_VAR *var)
absl::Status SetVarType(SCIP_VAR *var, GScipVarType var_type)
absl::Status SetBranchingPriority(SCIP_VAR *var, int priority)
absl::StatusOr< char > DefaultCharParamValue(const std::string ¶meter_name)
absl::Span< const double > LinearConstraintCoefficients(SCIP_CONS *constraint)
absl::Status SetUb(SCIP_VAR *var, double ub)
absl::Status SetObjCoef(SCIP_VAR *var, double obj_coef)
absl::StatusOr< SCIP_CONS * > AddSOS2Constraint(const GScipSOSData &sos_data, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
static std::string ScipVersion()
absl::StatusOr< SCIP_CONS * > AddQuadraticConstraint(const GScipQuadraticRange &range, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
absl::string_view Name(SCIP_VAR *var)
absl::StatusOr< SCIP_CONS * > AddSOS1Constraint(const GScipSOSData &sos_data, const std::string &name="", const GScipConstraintOptions &options=DefaultGScipConstraintOptions())
bool ObjectiveIsMaximize()
#define RETURN_ERROR_UNLESS(x)
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...
const GScipConstraintOptions & DefaultGScipConstraintOptions()
std::string ProtoEnumToString(ProtoEnumType enum_value)
int GScipMaxNumThreads(const GScipParameters ¶meters)
absl::Status LegacyScipSetSolverSpecificParameters(const std::string ¶meters, SCIP *scip)
const GScipVariableOptions & DefaultGScipVariableOptions()
absl::flat_hash_map< SCIP_VAR *, double > GScipSolution
#define SCIP_TO_STATUS(x)
#define RETURN_IF_SCIP_ERROR(x)
#define RETURN_IF_ERROR(expr)
std::vector< double > coefficients
std::vector< SCIP_Var * > variables
SCIP_VAR * indicator_variable
std::vector< SCIP_VAR * > variables
std::vector< double > coefficients
std::vector< SCIP_VAR * > operators
std::vector< SCIP_Var * > quadratic_variables1
std::vector< SCIP_Var * > quadratic_variables2
std::vector< SCIP_Var * > linear_variables
std::vector< double > linear_coefficients
std::vector< double > quadratic_coefficients
absl::flat_hash_map< SCIP_VAR *, double > primal_ray
std::vector< double > objective_values
std::vector< GScipSolution > solutions
std::vector< SCIP_VAR * > variables
std::vector< double > weights