always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reformat the code; [CP-SAT] add dominated columns presolve

Browse Source
This commit is contained in:
Laurent Perron
2020-10-28 13:42:36 +01:00
parent 335cf3df3d
commit 6467dc69b0
220 changed files with 9673 additions and 8137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
ortools/linear_solver/scip_callback.cc
View File

@@ -50,15 +50,15 @@ struct SCIP_ConshdlrData {
};
struct SCIP_ConsData {
void *data;
void* data;
};
namespace operations_research {
namespace {
int ScipNumVars(SCIP *scip) { return SCIPgetNOrigVars(scip); }
int ScipNumVars(SCIP* scip) { return SCIPgetNOrigVars(scip); }
SCIP_VAR *ScipGetVar(SCIP *scip, int var_index) {
SCIP_VAR* ScipGetVar(SCIP* scip, int var_index) {
DCHECK_GE(var_index, 0);
DCHECK_LT(var_index, ScipNumVars(scip));
return SCIPgetOrigVars(scip)[var_index];
@@ -67,13 +67,13 @@ SCIP_VAR *ScipGetVar(SCIP *scip, int var_index) {
} // namespace
ScipConstraintHandlerContext::ScipConstraintHandlerContext(
SCIP *scip, SCIP_SOL *solution, bool is_pseudo_solution)
SCIP* scip, SCIP_SOL* solution, bool is_pseudo_solution)
: scip_(scip),
solution_(solution),
is_pseudo_solution_(is_pseudo_solution) {}
double ScipConstraintHandlerContext::VariableValue(
const MPVariable *variable) const {
const MPVariable* variable) const {
return SCIPgetSolVal(scip_, solution_, ScipGetVar(scip_, variable->index()));
}
@@ -91,10 +91,10 @@ enum class ScipSeparationResult {
kDidNotFind
};
bool LinearConstraintIsViolated(const ScipConstraintHandlerContext &context,
const LinearRange &constraint) {
bool LinearConstraintIsViolated(const ScipConstraintHandlerContext& context,
const LinearRange& constraint) {
double a_times_x = 0;
for (const auto &coef_pair : constraint.linear_expr().terms()) {
for (const auto& coef_pair : constraint.linear_expr().terms()) {
a_times_x += coef_pair.second * context.VariableValue(coef_pair.first);
}
double violation = std::max(a_times_x - constraint.upper_bound(),
@@ -108,14 +108,14 @@ bool LinearConstraintIsViolated(const ScipConstraintHandlerContext &context,
// returns kCuttingPlaneAdded,
// else:
// returns kDidNotFind
ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
const ScipConstraintHandlerContext &context,
absl::Span<SCIP_CONS *> constraints,
ScipSeparationResult RunSeparation(internal::ScipCallbackRunner* runner,
const ScipConstraintHandlerContext& context,
absl::Span<SCIP_CONS*> constraints,
bool is_integral) {
ScipSeparationResult result = ScipSeparationResult::kDidNotFind;
SCIP *scip = context.scip();
for (SCIP_CONS *constraint : constraints) {
SCIP_CONSDATA *consdata = SCIPconsGetData(constraint);
SCIP* scip = context.scip();
for (SCIP_CONS* constraint : constraints) {
SCIP_CONSDATA* consdata = SCIPconsGetData(constraint);
CHECK(consdata != nullptr);
std::vector<CallbackRangeConstraint> user_suggested_constraints;
if (is_integral) {
@@ -126,7 +126,7 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
runner->SeparateFractionalSolution(context, consdata->data);
}
int num_constraints_added = 0;
for (const CallbackRangeConstraint &user_suggested_constraint :
for (const CallbackRangeConstraint& user_suggested_constraint :
user_suggested_constraints) {
if (!LinearConstraintIsViolated(context,
user_suggested_constraint.range)) {
@@ -135,7 +135,7 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
num_constraints_added++;
// Two code paths, one for cuts, one for lazy constraints. Cuts first:
if (user_suggested_constraint.is_cut) {
SCIP_ROW *row = nullptr;
SCIP_ROW* row = nullptr;
constexpr bool kModifiable = false;
constexpr bool kRemovable = true;
CHECK_OK(SCIP_TO_STATUS(SCIPcreateEmptyRowCons(
@@ -144,11 +144,11 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
user_suggested_constraint.range.upper_bound(),
user_suggested_constraint.local, kModifiable, kRemovable)));
CHECK_OK(SCIP_TO_STATUS(SCIPcacheRowExtensions(scip, row)));
for (const auto &coef_pair :
for (const auto& coef_pair :
user_suggested_constraint.range.linear_expr().terms()) {
// NOTE(user): the coefficients don't come out sorted. I don't
// think this matters.
SCIP_VAR *var = ScipGetVar(scip, coef_pair.first->index());
SCIP_VAR* var = ScipGetVar(scip, coef_pair.first->index());
const double coef = coef_pair.second;
CHECK_OK(SCIP_TO_STATUS(SCIPaddVarToRow(scip, row, var, coef)));
}
@@ -169,9 +169,9 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
}
} else {
// Lazy constraint path:
std::vector<SCIP_VAR *> vars;
std::vector<SCIP_VAR*> vars;
std::vector<double> coefs;
for (const auto &coef_pair :
for (const auto& coef_pair :
user_suggested_constraint.range.linear_expr().terms()) {
// NOTE(user): the coefficients don't come out sorted. I don't
// think this matters.
@@ -180,7 +180,7 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
}
const int num_vars = vars.size();
SCIP_CONS *scip_cons;
SCIP_CONS* scip_cons;
// TODO(user): Maybe it is better to expose more of these options,
// potentially through user_suggested_constraint.
CHECK_OK(SCIP_TO_STATUS(SCIPcreateConsLinear(
@@ -206,14 +206,14 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner *runner,
}
struct CallbackSetup {
SCIP_CONSHDLRDATA *scip_handler_data;
internal::ScipCallbackRunner *callback_runner;
SCIP_CONSHDLRDATA* scip_handler_data;
internal::ScipCallbackRunner* callback_runner;
ScipConstraintHandlerContext context;
absl::Span<SCIP_CONS *> useful_constraints;
absl::Span<SCIP_CONS *> unlikely_useful_constraints;
absl::Span<SCIP_CONS*> useful_constraints;
absl::Span<SCIP_CONS*> unlikely_useful_constraints;
CallbackSetup(SCIP *scip, SCIP_CONSHDLR *scip_handler, SCIP_CONS **conss,
int nconss, int nusefulconss, SCIP_SOL *sol,
CallbackSetup(SCIP* scip, SCIP_CONSHDLR* scip_handler, SCIP_CONS** conss,
int nconss, int nusefulconss, SCIP_SOL* sol,
bool is_pseudo_solution)
: scip_handler_data(SCIPconshdlrGetData(scip_handler)),
callback_runner(scip_handler_data->runner.get()),
@@ -234,7 +234,7 @@ extern "C" {
static SCIP_DECL_CONSFREE(ConstraintHandlerFreeC) {
VLOG(3) << "FreeC";
CHECK(scip != nullptr);
SCIP_CONSHDLRDATA *scip_handler_data = SCIPconshdlrGetData(conshdlr);
SCIP_CONSHDLRDATA* scip_handler_data = SCIPconshdlrGetData(conshdlr);
CHECK(scip_handler_data != nullptr);
delete scip_handler_data;
SCIPconshdlrSetData(conshdlr, nullptr);
@@ -341,8 +341,8 @@ static SCIP_DECL_CONSCHECK(CheckFeasibilityC) {
operations_research::CallbackSetup setup(scip, conshdlr, conss, nconss,
nconss, sol, false);
// All constraints are "useful" for this callback.
for (SCIP_CONS *constraint : setup.useful_constraints) {
SCIP_CONSDATA *consdata = SCIPconsGetData(constraint);
for (SCIP_CONS* constraint : setup.useful_constraints) {
SCIP_CONSDATA* consdata = SCIPconsGetData(constraint);
CHECK(consdata != nullptr);
if (!setup.callback_runner->IntegerSolutionFeasible(setup.context,
consdata->data)) {
@@ -395,7 +395,7 @@ static SCIP_DECL_CONSLOCK(VariableRoundingLockC) {
const int num_vars = operations_research::ScipNumVars(scip);
for (int i = 0; i < num_vars; ++i) {
SCIP_VAR *var = operations_research::ScipGetVar(scip, i);
SCIP_VAR* var = operations_research::ScipGetVar(scip, i);
SCIP_CALL(SCIPaddVarLocksType(scip, var, locktype, nlockspos + nlocksneg,
nlockspos + nlocksneg));
}
@@ -407,10 +407,10 @@ namespace operations_research {
namespace internal {
void AddConstraintHandlerImpl(
const ScipConstraintHandlerDescription &description,
std::unique_ptr<ScipCallbackRunner> runner, SCIP *scip) {
SCIP_CONSHDLR *c_scip_handler;
SCIP_CONSHDLRDATA *scip_handler_data = new SCIP_CONSHDLRDATA;
const ScipConstraintHandlerDescription& description,
std::unique_ptr<ScipCallbackRunner> runner, SCIP* scip) {
SCIP_CONSHDLR* c_scip_handler;
SCIP_CONSHDLRDATA* scip_handler_data = new SCIP_CONSHDLRDATA;
scip_handler_data->runner = std::move(runner);
CHECK_OK(SCIP_TO_STATUS(SCIPincludeConshdlrBasic(
@@ -430,16 +430,16 @@ void AddConstraintHandlerImpl(
SCIPsetConshdlrDelete(scip, c_scip_handler, ConstraintHandlerDeleteC)));
}
void AddCallbackConstraintImpl(SCIP *scip, const std::string &handler_name,
const std::string &constraint_name,
void *constraint_data,
const ScipCallbackConstraintOptions &options) {
SCIP_CONSHDLR *conshdlr = SCIPfindConshdlr(scip, handler_name.c_str());
void AddCallbackConstraintImpl(SCIP* scip, const std::string& handler_name,
const std::string& constraint_name,
void* constraint_data,
const ScipCallbackConstraintOptions& options) {
SCIP_CONSHDLR* conshdlr = SCIPfindConshdlr(scip, handler_name.c_str());
CHECK(conshdlr != nullptr)
<< "Constraint handler " << handler_name << " not registered with scip.";
SCIP_ConsData *consdata = new SCIP_ConsData;
SCIP_ConsData* consdata = new SCIP_ConsData;
consdata->data = constraint_data;
SCIP_CONS *constraint = nullptr;
SCIP_CONS* constraint = nullptr;
CHECK_OK(SCIP_TO_STATUS(SCIPcreateCons(
scip, &constraint, constraint_name.c_str(), conshdlr, consdata,
options.initial, options.separate, options.enforce, options.check,