Google OR-Tools: ortools/linear_solver/sat

Google OR-Tools: ortools/linear_solver/sat_interface.cc Source File

14#include <atomic>

15#include <cstdint>

16#include <string>

17#include <utility>

18#include <vector>

20#include "absl/base/attributes.h"

21#include "absl/status/status.h"

35 public:

48 std::atomic<bool>* interrupt) override {

49 return SatSolveProto(std::move(request), interrupt);

50 }

53 void Reset() override;

61 double new_value, double old_value) override;

64 double coefficient) override;

72 int64_t nodes() const override;

78 bool IsLP() const override;

79 bool IsMIP() const override;

96 const std::string& parameters) override;

97 absl::Status SetNumThreads(int num_threads) override;

99 private:

100 void NonIncrementalChange();

101

102 std::atomic<bool> interrupt_solve_;

104 int num_threads_ = 0;

105};

106

109

111

113 interrupt_solve_ = false;

114

115

118

120 solver_->SetSolverSpecificParametersAsString(

121 solver_->solver_specific_parameter_string_);

122

123

124 if (solver_->time_limit()) {

125 VLOG(1) << "Setting time limit = " << solver_->time_limit() << " ms.";

126 parameters_.set_max_time_in_seconds(

127 static_cast<double>(solver_->time_limit()) / 1000.0);

128 }

129

130

131 for (int i = 0; i < solver_->variables_.size(); ++i) {

133 }

134 for (int i = 0; i < solver_->constraints_.size(); ++i) {

136 }

137

142

144 SatSolveProto(std::move(request), &interrupt_solve_);

145

146

149

152 const absl::Status result = solver_->LoadSolutionFromProto(response);

153 if (!result.ok()) {

154 LOG(ERROR) << "LoadSolutionFromProto failed: " << result;

155 }

156 }

157

159}

160

162 interrupt_solve_ = true;

163 return true;

164}

165

167

169 NonIncrementalChange();

170}

171

173 NonIncrementalChange();

174}

175

177 NonIncrementalChange();

178}

179

181 NonIncrementalChange();

182}

183

185 NonIncrementalChange();

186}

187

189 NonIncrementalChange();

190}

191

194 double new_value, double old_value) {

195 NonIncrementalChange();

196}

197

199 NonIncrementalChange();

200}

201

203 double coefficient) {

204 NonIncrementalChange();

205}

206

208

210

214

216

220

224

228

232

234

236

238

240

242 parameters_.Clear();

243 parameters_.set_num_workers(num_threads_);

245}

246

248 num_threads_ = num_threads;

249 return absl::OkStatus();

250}

251

252

258

259

261

263 const std::string& parameters) {

265}

266

267void SatInterface::NonIncrementalChange() {

268

270}

271

272namespace {

273

274

275const void* const kRegisterSat ABSL_ATTRIBUTE_UNUSED = [] {

277 [](MPSolver* const solver) { return new SatInterface(solver); },

279 return nullptr;

280}();

281

282}

283

284}

void set_enable_internal_solver_output(bool value)

void set_solver_specific_parameters(Arg_ &&arg, Args_... args)

::operations_research::MPModelProto *PROTOBUF_NONNULL mutable_model()

::operations_research::MPSolverResponseStatus status() const

static MPSolverInterfaceFactoryRepository * GetInstance()

void Register(MPSolverInterfaceFactory factory, MPSolver::OptimizationProblemType problem_type, std::function< bool()> is_runtime_ready={})

void set_variable_as_extracted(int var_index, bool extracted)

friend class MPConstraint

void set_constraint_as_extracted(int ct_index, bool extracted)

void ResetExtractionInformation()

MPSolverInterface(MPSolver *solver)

void SetCommonParameters(const MPSolverParameters &param)

MPSolver::ResultStatus result_status_

SynchronizationStatus sync_status_

@ SAT_INTEGER_PROGRAMMING

The class for variables of a Mathematical Programming (MP) model.

void SetRelativeMipGap(double value) override

Definition sat_interface.cc:257

void AddVariable(MPVariable *var) override

Definition sat_interface.cc:188

void SetObjectiveOffset(double value) override

Definition sat_interface.cc:207

void SetCoefficient(MPConstraint *constraint, const MPVariable *variable, double new_value, double old_value) override

Definition sat_interface.cc:192

void SetVariableBounds(int index, double lb, double ub) override

Definition sat_interface.cc:172

bool SupportsDirectlySolveProto(std::atomic< bool > *interrupt) const override

Definition sat_interface.cc:44

absl::Status SetNumThreads(int num_threads) override

Definition sat_interface.cc:247

void * underlying_solver() override

Definition sat_interface.cc:233

void ExtractObjective() override

Definition sat_interface.cc:239

void SetObjectiveCoefficient(const MPVariable *variable, double coefficient) override

Definition sat_interface.cc:202

void AddRowConstraint(MPConstraint *ct) override

Definition sat_interface.cc:184

void Reset() override

Definition sat_interface.cc:166

MPSolver::ResultStatus Solve(const MPSolverParameters &param) override

Definition sat_interface.cc:112

void SetScalingMode(int value) override

Definition sat_interface.cc:255

void SetVariableInteger(int index, bool integer) override

Definition sat_interface.cc:176

void ClearConstraint(MPConstraint *constraint) override

Definition sat_interface.cc:198

int64_t nodes() const override

Definition sat_interface.cc:215

void ExtractNewConstraints() override

Definition sat_interface.cc:237

bool IsContinuous() const override

Definition sat_interface.cc:225

bool IsMIP() const override

Definition sat_interface.cc:227

bool InterruptSolve() override

Definition sat_interface.cc:161

void SetPresolveMode(int value) override

Definition sat_interface.cc:260

std::string SolverVersion() const override

Definition sat_interface.cc:229

void SetDualTolerance(double value) override

Definition sat_interface.cc:254

void SetOptimizationDirection(bool maximize) override

Definition sat_interface.cc:168

void ExtractNewVariables() override

Definition sat_interface.cc:235

bool IsLP() const override

Definition sat_interface.cc:226

int64_t iterations() const override

Definition sat_interface.cc:211

bool SetSolverSpecificParametersAsString(const std::string &parameters) override

Definition sat_interface.cc:262

~SatInterface() override

Definition sat_interface.cc:110

bool AddIndicatorConstraint(MPConstraint *const ct) override

Definition sat_interface.cc:68

MPSolutionResponse DirectlySolveProto(LazyMutableCopy< MPModelRequest > request, std::atomic< bool > *interrupt) override

Definition sat_interface.cc:47

void SetConstraintBounds(int index, double lb, double ub) override

Definition sat_interface.cc:180

void ClearObjective() override

Definition sat_interface.cc:209

MPSolver::BasisStatus column_status(int variable_index) const override

Definition sat_interface.cc:221

void SetPrimalTolerance(double value) override

Definition sat_interface.cc:253

MPSolver::BasisStatus row_status(int constraint_index) const override

Definition sat_interface.cc:217

void SetLpAlgorithm(int value) override

Definition sat_interface.cc:256

void SetParameters(const MPSolverParameters &param) override

Definition sat_interface.cc:241

SatInterface(MPSolver *solver)

Definition sat_interface.cc:107

std::string CpSatSolverVersion()

Returns a string that describes the version of the solver.

MPSolutionResponse SatSolveProto(LazyMutableCopy< MPModelRequest > request, std::atomic< bool > *interrupt_solve, std::function< void(const std::string &)> logging_callback, std::function< void(const MPSolution &)> solution_callback, std::function< void(const double)> best_bound_callback)

std::string EncodeParametersAsString(const P &parameters)

bool ProtobufTextFormatMergeFromString(absl::string_view proto_text_string, ProtoType *proto)