Google OR-Tools: ortools/linear_solver/scip

Google OR-Tools: ortools/linear_solver/scip_callback.h Source File

20#ifndef ORTOOLS_LINEAR_SOLVER_SCIP_CALLBACK_H_

21#define ORTOOLS_LINEAR_SOLVER_SCIP_CALLBACK_H_

23#include <cstdint>

24#include <memory>

25#include <string>

26#include <vector>

30#include "scip/type_scip.h"

31#include "scip/type_sol.h"

77};

80 public:

100 private:

102 SCIP_SOL* solution_;

103 bool is_pseudo_solution_;

104};

105

112

113template <typename Constraint>

115 public:

121 return description_;

122 }

123

124

125

129

130

131

137

138

144

145

151

152 private:

154};

155

156

157template <typename Constraint>

160

173

174

175template <typename ConstraintData>

178 const std::string& constraint_name,

179 const ConstraintData* constraint_data,

181

182

183

185

187 public:

191

194

197

200};

201

202template <typename ConstraintData>

204 public:

207 : handler_(handler) {}

208

211 void* constraint_data) override {

212 return handler_->SeparateFractionalSolution(

213 context, *static_cast<ConstraintData*>(constraint_data));

214 }

215

218 void* constraint_data) override {

219 return handler_->SeparateIntegerSolution(

220 context, *static_cast<ConstraintData*>(constraint_data));

221 }

222

224 void* constraint_data) override {

225 return handler_->FractionalSolutionFeasible(

226 context, *static_cast<ConstraintData*>(constraint_data));

227 }

228

230 void* constraint_data) override {

231 return handler_->IntegerSolutionFeasible(

232 context, *static_cast<ConstraintData*>(constraint_data));

233 }

234

235 private:

237};

238

241 std::unique_ptr<ScipCallbackRunner> runner, SCIP* scip);

242

244 const std::string& constraint_name,

245 void* constraint_data,

247

248}

249

250template <typename ConstraintData>

252 SCIP* scip) {

256 handler),

257 scip);

258}

259

260template <typename ConstraintData>

263 const std::string& constraint_name,

264 const ConstraintData* constraint_data,

268 static_cast<void*>(const_cast<ConstraintData*>(constraint_data)),

269 options);

270}

271

272}

273

274#endif

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

Definition scip_callback.h:79

int64_t CurrentNodeId() const

double VariableValue(const MPVariable *variable) const

ScipConstraintHandlerContext(SCIP *scip, SCIP_SOL *solution, bool is_pseudo_solution)

int64_t NumNodesProcessed() const

SCIP * scip() const

Definition scip_callback.h:89

bool is_pseudo_solution() const

Definition scip_callback.h:98

Definition scip_callback.h:114

virtual ~ScipConstraintHandler()

Definition scip_callback.h:119

ScipConstraintHandler(const ScipConstraintHandlerDescription &description)

Definition scip_callback.h:116

const ScipConstraintHandlerDescription & description() const

Definition scip_callback.h:120

virtual bool FractionalSolutionFeasible(const ScipConstraintHandlerContext &context, const Constraint &constraint)

Definition scip_callback.h:139

virtual std::vector< CallbackRangeConstraint > SeparateIntegerSolution(const ScipConstraintHandlerContext &context, const Constraint &constraint)

Definition scip_callback.h:132

virtual std::vector< CallbackRangeConstraint > SeparateFractionalSolution(const ScipConstraintHandlerContext &context, const Constraint &constraint)=0

virtual bool IntegerSolutionFeasible(const ScipConstraintHandlerContext &context, const Constraint &constraint)

Definition scip_callback.h:146

Definition scip_callback.h:203

std::vector< CallbackRangeConstraint > SeparateIntegerSolution(const ScipConstraintHandlerContext &context, void *constraint_data) override

Definition scip_callback.h:216

ScipCallbackRunnerImpl(ScipConstraintHandler< ConstraintData > *handler)

Definition scip_callback.h:205

std::vector< CallbackRangeConstraint > SeparateFractionalSolution(const ScipConstraintHandlerContext &context, void *constraint_data) override

Definition scip_callback.h:209

bool FractionalSolutionFeasible(const ScipConstraintHandlerContext &context, void *constraint_data) override

Definition scip_callback.h:223

bool IntegerSolutionFeasible(const ScipConstraintHandlerContext &context, void *constraint_data) override

Definition scip_callback.h:229

Definition scip_callback.h:186

virtual std::vector< CallbackRangeConstraint > SeparateFractionalSolution(const ScipConstraintHandlerContext &context, void *constraint)=0

virtual std::vector< CallbackRangeConstraint > SeparateIntegerSolution(const ScipConstraintHandlerContext &context, void *constraint)=0

virtual bool IntegerSolutionFeasible(const ScipConstraintHandlerContext &context, void *constraint)=0

virtual bool FractionalSolutionFeasible(const ScipConstraintHandlerContext &context, void *constraint)=0

virtual ~ScipCallbackRunner()

Definition scip_callback.h:188

void AddConstraintHandlerImpl(const ScipConstraintHandlerDescription &description, std::unique_ptr< ScipCallbackRunner > runner, SCIP *scip)

void AddCallbackConstraintImpl(SCIP *scip, const std::string &handler_name, const std::string &constraint_name, void *constraint_data, const ScipCallbackConstraintOptions &options)

void AddCallbackConstraint(SCIP *scip, ScipConstraintHandler< ConstraintData > *handler, const std::string &constraint_name, const ConstraintData *constraint_data, const ScipCallbackConstraintOptions &options)

Definition scip_callback.h:261

Select next search node to expand Select next item_i to add this new search node to the search Generate a new search node where item_i is not in the knapsack Check validity of this new partial solution(using propagators) - If valid

void RegisterConstraintHandler(ScipConstraintHandler< Constraint > *handler, SCIP *scip)

Definition scip_callback.h:106

bool is_cut

Definition scip_callback.h:108

std::string name

Definition scip_callback.h:109

LinearRange range

Definition scip_callback.h:107

bool local

Definition scip_callback.h:110

Definition scip_callback.h:161

bool removable