or-tools 0.5.0 → 0.5.1

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 405e26b51140e6605acd8904d7e90e0e7f48b7cfd83641fef6e2e737e7b8cda4
4
- data.tar.gz: e6e0506979a829c260f8bae70e7769524d59d83b7a52e1cadfb6e553d8116587
3
+ metadata.gz: 0a848cf114ad9ca6d778daf6cb19ff78b3c4015c4b39eb6b6274e61c4175b87d
4
+ data.tar.gz: bb3c6b79787a0793367ab900b95caf8fa0b242f76fd0c2adc2a434056648e1e9
5
5
  SHA512:
6
- metadata.gz: 237e13e7340682d974602743de724031c28c99add58c4cf49e670bb05f4fa0c691dcf00dd75797a9ab3efcc9b5505a96f3a2a3d542db8c8746652ec114b5a258
7
- data.tar.gz: 5c782dd281122001095663da47fce8279f5a2c29b6eed65e2288df6727c55724ef424d4c3bfda3ed3b4ce53493964b88d64f67fc843e97dafd98f3e21a4c5183
6
+ metadata.gz: 571acd73a42c0e3181e256d30c42f8b18d7bcf01ada104a181c7e2b4034358d14409ba1904017c31a4c3c07b15744ac8eeb9422f5d8074c9e2c818bc38bf7ec3
7
+ data.tar.gz: 762bfc272f728f1b04af4d153591b52798415c2729d4111445779b66c356b9714a4b88eb8ba6546bc43c017184868cf9adcb91df980c105be3a72f2555a8d7f2
data/CHANGELOG.md CHANGED
@@ -1,3 +1,7 @@
1
+ ## 0.5.1 (2021-05-23)
2
+
3
+ - Updated to Rice 4
4
+
1
5
  ## 0.5.0 (2021-04-30)
2
6
 
3
7
  - Updated OR-Tools to 9.0
@@ -1,12 +1,9 @@
1
1
  #include <ortools/graph/assignment.h>
2
2
 
3
- #include <rice/Array.hpp>
4
- #include <rice/Constructor.hpp>
5
- #include <rice/Module.hpp>
3
+ #include "ext.h"
6
4
 
7
5
  using operations_research::SimpleLinearSumAssignment;
8
6
 
9
- using Rice::Array;
10
7
  using Rice::Symbol;
11
8
 
12
9
  void init_assignment(Rice::Module& m) {
@@ -23,7 +20,7 @@ void init_assignment(Rice::Module& m) {
23
20
  .define_method("assignment_cost", &SimpleLinearSumAssignment::AssignmentCost)
24
21
  .define_method(
25
22
  "solve",
26
- *[](SimpleLinearSumAssignment& self) {
23
+ [](SimpleLinearSumAssignment& self) {
27
24
  auto status = self.Solve();
28
25
 
29
26
  if (status == SimpleLinearSumAssignment::Status::OPTIMAL) {
@@ -1,8 +1,6 @@
1
1
  #include <ortools/algorithms/knapsack_solver.h>
2
2
 
3
- #include <rice/Array.hpp>
4
- #include <rice/Constructor.hpp>
5
- #include <rice/Module.hpp>
3
+ #include "ext.h"
6
4
 
7
5
  using operations_research::KnapsackSolver;
8
6
 
@@ -10,16 +8,31 @@ using Rice::Array;
10
8
  using Rice::Object;
11
9
  using Rice::Symbol;
12
10
 
13
- template<>
14
- inline
15
- KnapsackSolver::SolverType from_ruby<KnapsackSolver::SolverType>(Object x)
11
+ namespace Rice::detail
16
12
  {
17
- std::string s = Symbol(x).str();
18
- if (s == "branch_and_bound") {
19
- return KnapsackSolver::KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER;
20
- } else {
21
- throw std::runtime_error("Unknown solver type: " + s);
22
- }
13
+ template<>
14
+ struct Type<KnapsackSolver::SolverType>
15
+ {
16
+ static bool verify()
17
+ {
18
+ return true;
19
+ }
20
+ };
21
+
22
+ template<>
23
+ class From_Ruby<KnapsackSolver::SolverType>
24
+ {
25
+ public:
26
+ KnapsackSolver::SolverType convert(VALUE x)
27
+ {
28
+ auto s = Symbol(x).str();
29
+ if (s == "branch_and_bound") {
30
+ return KnapsackSolver::KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER;
31
+ } else {
32
+ throw std::runtime_error("Unknown solver type: " + s);
33
+ }
34
+ }
35
+ };
23
36
  }
24
37
 
25
38
  void init_bin_packing(Rice::Module& m) {
@@ -29,27 +42,7 @@ void init_bin_packing(Rice::Module& m) {
29
42
  .define_method("best_solution_contains?", &KnapsackSolver::BestSolutionContains)
30
43
  .define_method(
31
44
  "init",
32
- *[](KnapsackSolver& self, Array rb_values, Array rb_weights, Array rb_capacities) {
33
- std::vector<int64_t> values;
34
- for (std::size_t i = 0; i < rb_values.size(); ++i) {
35
- values.push_back(from_ruby<int64_t>(rb_values[i]));
36
- }
37
-
38
- std::vector<std::vector<int64_t>> weights;
39
- for (std::size_t i = 0; i < rb_weights.size(); ++i) {
40
- Array rb_w = Array(rb_weights[i]);
41
- std::vector<int64_t> w;
42
- for (std::size_t j = 0; j < rb_w.size(); ++j) {
43
- w.push_back(from_ruby<int64_t>(rb_w[j]));
44
- }
45
- weights.push_back(w);
46
- }
47
-
48
- std::vector<int64_t> capacities;
49
- for (std::size_t i = 0; i < rb_capacities.size(); ++i) {
50
- capacities.push_back(from_ruby<int64_t>(rb_capacities[i]));
51
- }
52
-
45
+ [](KnapsackSolver& self, std::vector<int64_t> values, std::vector<std::vector<int64_t>> weights, std::vector<int64_t> capacities) {
53
46
  self.Init(values, weights, capacities);
54
47
  });
55
48
  }
@@ -1,9 +1,7 @@
1
1
  #include <google/protobuf/text_format.h>
2
2
  #include <ortools/sat/cp_model.h>
3
3
 
4
- #include <rice/Array.hpp>
5
- #include <rice/Constructor.hpp>
6
- #include <rice/Module.hpp>
4
+ #include "ext.h"
7
5
 
8
6
  using operations_research::sat::BoolVar;
9
7
  using operations_research::sat::Constraint;
@@ -28,130 +26,75 @@ using Rice::Symbol;
28
26
  Class rb_cBoolVar;
29
27
  Class rb_cSatIntVar;
30
28
 
31
- template<>
32
- inline
33
- LinearExpr from_ruby<LinearExpr>(Object x)
29
+ namespace Rice::detail
34
30
  {
35
- LinearExpr expr;
36
-
37
- if (x.respond_to("to_i")) {
38
- expr = from_ruby<int64_t>(x.call("to_i"));
39
- } else if (x.respond_to("vars")) {
40
- Array vars = x.call("vars");
41
- for (auto const& var: vars) {
42
- auto cvar = (Array) var;
43
- Object o = cvar[0];
44
- if (o.is_a(rb_cBoolVar)) {
45
- expr.AddTerm(from_ruby<BoolVar>(cvar[0]), from_ruby<int64_t>(cvar[1]));
46
- } else if (o.is_a(rb_cInteger)) {
47
- expr.AddConstant(from_ruby<int64_t>(cvar[0]) * from_ruby<int64_t>(cvar[1]));
48
- } else {
49
- expr.AddTerm(from_ruby<IntVar>(cvar[0]), from_ruby<int64_t>(cvar[1]));
50
- }
31
+ template<>
32
+ struct Type<LinearExpr>
33
+ {
34
+ static bool verify()
35
+ {
36
+ return true;
51
37
  }
52
- } else if (x.is_a(rb_cBoolVar)) {
53
- expr = from_ruby<BoolVar>(x);
54
- } else {
55
- expr = from_ruby<IntVar>(x);
56
- }
38
+ };
57
39
 
58
- return expr;
59
- }
60
-
61
- // need a wrapper class since absl::Span doesn't own
62
- class IntVarSpan {
63
- std::vector<IntVar> vec;
40
+ template<>
41
+ class From_Ruby<LinearExpr>
42
+ {
64
43
  public:
65
- IntVarSpan(Object x) {
66
- Array a = Array(x);
67
- vec.reserve(a.size());
68
- for (std::size_t i = 0; i < a.size(); ++i) {
69
- vec.push_back(from_ruby<IntVar>(a[i]));
70
- }
71
- }
72
- operator absl::Span<const IntVar>() {
73
- return absl::Span<const IntVar>(vec);
74
- }
75
- };
44
+ LinearExpr convert(VALUE v)
45
+ {
46
+ Object x(v);
47
+ LinearExpr expr;
76
48
 
77
- template<>
78
- inline
79
- IntVarSpan from_ruby<IntVarSpan>(Object x)
80
- {
81
- return IntVarSpan(x);
82
- }
49
+ if (x.respond_to("to_i")) {
50
+ expr = From_Ruby<int64_t>().convert(x.call("to_i").value());
51
+ } else if (x.respond_to("vars")) {
52
+ Array vars = x.call("vars");
53
+ for (const auto& v : vars) {
54
+ // TODO clean up
55
+ auto cvar = (Array) v;
56
+ Object var = cvar[0];
57
+ auto coeff = From_Ruby<int64_t>().convert(cvar[1].value());
83
58
 
84
- // need a wrapper class since absl::Span doesn't own
85
- class IntervalVarSpan {
86
- std::vector<IntervalVar> vec;
87
- public:
88
- IntervalVarSpan(Object x) {
89
- Array a = Array(x);
90
- vec.reserve(a.size());
91
- for (std::size_t i = 0; i < a.size(); ++i) {
92
- vec.push_back(from_ruby<IntervalVar>(a[i]));
59
+ if (var.is_a(rb_cBoolVar)) {
60
+ expr.AddTerm(From_Ruby<BoolVar>().convert(var.value()), coeff);
61
+ } else if (var.is_a(rb_cInteger)) {
62
+ expr.AddConstant(From_Ruby<int64_t>().convert(var.value()) * coeff);
63
+ } else {
64
+ expr.AddTerm(From_Ruby<IntVar>().convert(var.value()), coeff);
65
+ }
66
+ }
67
+ } else {
68
+ if (x.is_a(rb_cBoolVar)) {
69
+ expr = From_Ruby<BoolVar>().convert(x.value());
70
+ } else {
71
+ expr = From_Ruby<IntVar>().convert(x.value());
72
+ }
93
73
  }
94
- }
95
- operator absl::Span<const IntervalVar>() {
96
- return absl::Span<const IntervalVar>(vec);
97
- }
98
- };
99
74
 
100
- template<>
101
- inline
102
- IntervalVarSpan from_ruby<IntervalVarSpan>(Object x)
103
- {
104
- return IntervalVarSpan(x);
105
- }
106
-
107
- // need a wrapper class since absl::Span doesn't own
108
- class LinearExprSpan {
109
- std::vector<LinearExpr> vec;
110
- public:
111
- LinearExprSpan(Object x) {
112
- Array a = Array(x);
113
- vec.reserve(a.size());
114
- for (std::size_t i = 0; i < a.size(); ++i) {
115
- vec.push_back(from_ruby<LinearExpr>(a[i]));
116
- }
117
- }
118
- operator absl::Span<const LinearExpr>() {
119
- return absl::Span<const LinearExpr>(vec);
75
+ return expr;
120
76
  }
121
- };
77
+ };
122
78
 
123
- template<>
124
- inline
125
- LinearExprSpan from_ruby<LinearExprSpan>(Object x)
126
- {
127
- return LinearExprSpan(x);
128
- }
129
-
130
- // need a wrapper class since absl::Span doesn't own
131
- class BoolVarSpan {
132
- std::vector<BoolVar> vec;
79
+ template<>
80
+ class From_Ruby<std::vector<BoolVar>>
81
+ {
133
82
  public:
134
- BoolVarSpan(Object x) {
135
- Array a = Array(x);
83
+ std::vector<BoolVar> convert(VALUE v)
84
+ {
85
+ auto a = Array(v);
86
+ std::vector<BoolVar> vec;
136
87
  vec.reserve(a.size());
137
- for (std::size_t i = 0; i < a.size(); ++i) {
138
- if (((Object) a[i]).is_a(rb_cSatIntVar)) {
139
- vec.push_back(from_ruby<IntVar>(a[i]).ToBoolVar());
88
+ for (const Object v : a) {
89
+ if (v.is_a(rb_cSatIntVar)) {
90
+ vec.push_back(From_Ruby<IntVar>().convert(v.value()).ToBoolVar());
140
91
  } else {
141
- vec.push_back(from_ruby<BoolVar>(a[i]));
92
+ vec.push_back(From_Ruby<BoolVar>().convert(v.value()));
142
93
  }
143
94
  }
95
+ return vec;
144
96
  }
145
- operator absl::Span<const BoolVar>() {
146
- return absl::Span<const BoolVar>(vec);
147
- }
148
- };
149
-
150
- template<>
151
- inline
152
- BoolVarSpan from_ruby<BoolVarSpan>(Object x)
153
- {
154
- return BoolVarSpan(x);
97
+ };
155
98
  }
156
99
 
157
100
  void init_constraint(Rice::Module& m) {
@@ -164,14 +107,14 @@ void init_constraint(Rice::Module& m) {
164
107
  Rice::define_class_under<Constraint>(m, "SatConstraint")
165
108
  .define_method(
166
109
  "only_enforce_if",
167
- *[](Constraint& self, Object literal) {
110
+ [](Constraint& self, Object literal) {
168
111
  if (literal.is_a(rb_cSatIntVar)) {
169
- return self.OnlyEnforceIf(from_ruby<IntVar>(literal).ToBoolVar());
112
+ return self.OnlyEnforceIf(Rice::detail::From_Ruby<IntVar>().convert(literal).ToBoolVar());
170
113
  } else if (literal.is_a(rb_cArray)) {
171
114
  // TODO support IntVarSpan
172
- return self.OnlyEnforceIf(from_ruby<BoolVarSpan>(literal));
115
+ return self.OnlyEnforceIf(Rice::detail::From_Ruby<std::vector<BoolVar>>().convert(literal));
173
116
  } else {
174
- return self.OnlyEnforceIf(from_ruby<BoolVar>(literal));
117
+ return self.OnlyEnforceIf(Rice::detail::From_Ruby<BoolVar>().convert(literal));
175
118
  }
176
119
  });
177
120
 
@@ -181,7 +124,7 @@ void init_constraint(Rice::Module& m) {
181
124
  .define_method("not", &BoolVar::Not)
182
125
  .define_method(
183
126
  "inspect",
184
- *[](BoolVar& self) {
127
+ [](BoolVar& self) {
185
128
  String name(self.Name());
186
129
  return "#<ORTools::BoolVar @name=" + name.inspect().str() + ">";
187
130
  });
@@ -189,7 +132,7 @@ void init_constraint(Rice::Module& m) {
189
132
  Rice::define_class_under<SatParameters>(m, "SatParameters")
190
133
  .define_constructor(Rice::Constructor<SatParameters>())
191
134
  .define_method("max_time_in_seconds=",
192
- *[](SatParameters& self, double value) {
135
+ [](SatParameters& self, double value) {
193
136
  self.set_max_time_in_seconds(value);
194
137
  });
195
138
 
@@ -197,238 +140,199 @@ void init_constraint(Rice::Module& m) {
197
140
  .define_constructor(Rice::Constructor<CpModelBuilder>())
198
141
  .define_method(
199
142
  "new_int_var",
200
- *[](CpModelBuilder& self, int64_t start, int64_t end, const std::string& name) {
143
+ [](CpModelBuilder& self, int64_t start, int64_t end, const std::string& name) {
201
144
  const operations_research::Domain domain(start, end);
202
145
  return self.NewIntVar(domain).WithName(name);
203
146
  })
204
147
  .define_method(
205
148
  "new_bool_var",
206
- *[](CpModelBuilder& self, const std::string& name) {
149
+ [](CpModelBuilder& self, const std::string& name) {
207
150
  return self.NewBoolVar().WithName(name);
208
151
  })
209
152
  .define_method(
210
153
  "new_constant",
211
- *[](CpModelBuilder& self, int64_t value) {
154
+ [](CpModelBuilder& self, int64_t value) {
212
155
  return self.NewConstant(value);
213
156
  })
214
157
  .define_method(
215
158
  "true_var",
216
- *[](CpModelBuilder& self) {
159
+ [](CpModelBuilder& self) {
217
160
  return self.TrueVar();
218
161
  })
219
162
  .define_method(
220
163
  "false_var",
221
- *[](CpModelBuilder& self) {
164
+ [](CpModelBuilder& self) {
222
165
  return self.FalseVar();
223
166
  })
224
167
  .define_method(
225
168
  "new_interval_var",
226
- *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, const std::string& name) {
169
+ [](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, const std::string& name) {
227
170
  return self.NewIntervalVar(start, size, end).WithName(name);
228
171
  })
229
172
  .define_method(
230
173
  "new_optional_interval_var",
231
- *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, BoolVar presence, const std::string& name) {
174
+ [](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, BoolVar presence, const std::string& name) {
232
175
  return self.NewOptionalIntervalVar(start, size, end, presence).WithName(name);
233
176
  })
234
177
  .define_method(
235
178
  "add_bool_or",
236
- *[](CpModelBuilder& self, BoolVarSpan literals) {
179
+ [](CpModelBuilder& self, std::vector<BoolVar> literals) {
237
180
  return self.AddBoolOr(literals);
238
181
  })
239
182
  .define_method(
240
183
  "add_bool_and",
241
- *[](CpModelBuilder& self, BoolVarSpan literals) {
184
+ [](CpModelBuilder& self, std::vector<BoolVar> literals) {
242
185
  return self.AddBoolAnd(literals);
243
186
  })
244
187
  .define_method(
245
188
  "add_bool_xor",
246
- *[](CpModelBuilder& self, BoolVarSpan literals) {
189
+ [](CpModelBuilder& self, std::vector<BoolVar> literals) {
247
190
  return self.AddBoolXor(literals);
248
191
  })
249
192
  .define_method(
250
193
  "add_implication",
251
- *[](CpModelBuilder& self, BoolVar a, BoolVar b) {
194
+ [](CpModelBuilder& self, BoolVar a, BoolVar b) {
252
195
  return self.AddImplication(a, b);
253
196
  })
254
197
  .define_method(
255
198
  "add_equality",
256
- *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
199
+ [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
257
200
  return self.AddEquality(x, y);
258
201
  })
259
202
  .define_method(
260
203
  "add_greater_or_equal",
261
- *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
204
+ [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
262
205
  return self.AddGreaterOrEqual(x, y);
263
206
  })
264
207
  .define_method(
265
208
  "add_greater_than",
266
- *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
209
+ [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
267
210
  return self.AddGreaterThan(x, y);
268
211
  })
269
212
  .define_method(
270
213
  "add_less_or_equal",
271
- *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
214
+ [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
272
215
  return self.AddLessOrEqual(x, y);
273
216
  })
274
217
  .define_method(
275
218
  "add_less_than",
276
- *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
219
+ [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
277
220
  return self.AddLessThan(x, y);
278
221
  })
279
222
  // TODO add domain
280
223
  // .define_method(
281
224
  // "add_linear_constraint",
282
- // *[](CpModelBuilder& self, LinearExpr expr, Domain domain) {
225
+ // [](CpModelBuilder& self, LinearExpr expr, Domain domain) {
283
226
  // return self.AddLinearConstraint(expr, domain);
284
227
  // })
285
228
  .define_method(
286
229
  "add_not_equal",
287
- *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
230
+ [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
288
231
  return self.AddNotEqual(x, y);
289
232
  })
290
233
  .define_method(
291
234
  "add_all_different",
292
- *[](CpModelBuilder& self, IntVarSpan vars) {
235
+ [](CpModelBuilder& self, std::vector<IntVar> vars) {
293
236
  return self.AddAllDifferent(vars);
294
237
  })
295
238
  .define_method(
296
239
  "add_inverse_constraint",
297
- *[](CpModelBuilder& self, IntVarSpan variables, IntVarSpan inverse_variables) {
240
+ [](CpModelBuilder& self, std::vector<IntVar> variables, std::vector<IntVar> inverse_variables) {
298
241
  return self.AddInverseConstraint(variables, inverse_variables);
299
242
  })
300
243
  .define_method(
301
244
  "add_min_equality",
302
- *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
245
+ [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
303
246
  return self.AddMinEquality(target, vars);
304
247
  })
305
248
  .define_method(
306
249
  "add_lin_min_equality",
307
- *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
250
+ [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> exprs) {
308
251
  return self.AddLinMinEquality(target, exprs);
309
252
  })
310
253
  .define_method(
311
254
  "add_max_equality",
312
- *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
255
+ [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
313
256
  return self.AddMaxEquality(target, vars);
314
257
  })
315
258
  .define_method(
316
259
  "add_lin_max_equality",
317
- *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
260
+ [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> exprs) {
318
261
  return self.AddLinMaxEquality(target, exprs);
319
262
  })
320
263
  .define_method(
321
264
  "add_division_equality",
322
- *[](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
265
+ [](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
323
266
  return self.AddDivisionEquality(target, numerator, denominator);
324
267
  })
325
268
  .define_method(
326
269
  "add_abs_equality",
327
- *[](CpModelBuilder& self, IntVar target, IntVar var) {
270
+ [](CpModelBuilder& self, IntVar target, IntVar var) {
328
271
  return self.AddAbsEquality(target, var);
329
272
  })
330
273
  .define_method(
331
274
  "add_modulo_equality",
332
- *[](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
275
+ [](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
333
276
  return self.AddModuloEquality(target, var, mod);
334
277
  })
335
278
  .define_method(
336
279
  "add_product_equality",
337
- *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
280
+ [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
338
281
  return self.AddProductEquality(target, vars);
339
282
  })
340
283
  .define_method(
341
284
  "add_no_overlap",
342
- *[](CpModelBuilder& self, IntervalVarSpan vars) {
285
+ [](CpModelBuilder& self, std::vector<IntervalVar> vars) {
343
286
  return self.AddNoOverlap(vars);
344
287
  })
345
288
  .define_method(
346
289
  "maximize",
347
- *[](CpModelBuilder& self, LinearExpr expr) {
290
+ [](CpModelBuilder& self, LinearExpr expr) {
348
291
  self.Maximize(expr);
349
292
  })
350
293
  .define_method(
351
294
  "minimize",
352
- *[](CpModelBuilder& self, LinearExpr expr) {
295
+ [](CpModelBuilder& self, LinearExpr expr) {
353
296
  self.Minimize(expr);
354
297
  })
355
298
  .define_method(
356
299
  "scale_objective_by",
357
- *[](CpModelBuilder& self, double scaling) {
300
+ [](CpModelBuilder& self, double scaling) {
358
301
  self.ScaleObjectiveBy(scaling);
359
302
  })
360
303
  .define_method(
361
304
  "add_hint",
362
- *[](CpModelBuilder& self, IntVar var, int64_t value) {
305
+ [](CpModelBuilder& self, IntVar var, int64_t value) {
363
306
  self.AddHint(var, value);
364
307
  })
365
308
  .define_method(
366
309
  "clear_hints",
367
- *[](CpModelBuilder& self) {
310
+ [](CpModelBuilder& self) {
368
311
  self.ClearHints();
369
312
  })
370
313
  .define_method(
371
314
  "add_assumption",
372
- *[](CpModelBuilder& self, BoolVar lit) {
315
+ [](CpModelBuilder& self, BoolVar lit) {
373
316
  self.AddAssumption(lit);
374
317
  })
375
318
  .define_method(
376
319
  "add_assumptions",
377
- *[](CpModelBuilder& self, BoolVarSpan literals) {
320
+ [](CpModelBuilder& self, std::vector<BoolVar> literals) {
378
321
  self.AddAssumptions(literals);
379
322
  })
380
323
  .define_method(
381
324
  "clear_assumptions",
382
- *[](CpModelBuilder& self) {
325
+ [](CpModelBuilder& self) {
383
326
  self.ClearAssumptions();
384
327
  })
385
328
  .define_method(
386
329
  "to_s",
387
- *[](CpModelBuilder& self) {
330
+ [](CpModelBuilder& self) {
388
331
  std::string proto_string;
389
332
  google::protobuf::TextFormat::PrintToString(self.Proto(), &proto_string);
390
333
  return proto_string;
391
334
  });
392
335
 
393
- Rice::define_class_under(m, "CpSolver")
394
- .define_method(
395
- "_solve_with_observer",
396
- *[](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback, bool all_solutions) {
397
- Model m;
398
-
399
- if (all_solutions) {
400
- // set parameters for SearchForAllSolutions
401
- parameters.set_enumerate_all_solutions(true);
402
- }
403
- m.Add(NewSatParameters(parameters));
404
-
405
- m.Add(NewFeasibleSolutionObserver(
406
- [callback](const CpSolverResponse& r) {
407
- // TODO find a better way to do this
408
- callback.call("response=", r);
409
- callback.call("on_solution_callback");
410
- })
411
- );
412
- return SolveCpModel(model.Build(), &m);
413
- })
414
- .define_method(
415
- "_solve",
416
- *[](Object self, CpModelBuilder& model, SatParameters& parameters) {
417
- Model m;
418
- m.Add(NewSatParameters(parameters));
419
- return SolveCpModel(model.Build(), &m);
420
- })
421
- .define_method(
422
- "_solution_integer_value",
423
- *[](Object self, CpSolverResponse& response, IntVar& x) {
424
- return SolutionIntegerValue(response, x);
425
- })
426
- .define_method(
427
- "_solution_boolean_value",
428
- *[](Object self, CpSolverResponse& response, BoolVar& x) {
429
- return SolutionBooleanValue(response, x);
430
- });
431
-
432
336
  Rice::define_class_under<CpSolverResponse>(m, "CpSolverResponse")
433
337
  .define_method("objective_value", &CpSolverResponse::objective_value)
434
338
  .define_method("num_conflicts", &CpSolverResponse::num_conflicts)
@@ -436,14 +340,14 @@ void init_constraint(Rice::Module& m) {
436
340
  .define_method("wall_time", &CpSolverResponse::wall_time)
437
341
  .define_method(
438
342
  "solution_integer_value",
439
- *[](CpSolverResponse& self, IntVar& x) {
343
+ [](CpSolverResponse& self, IntVar& x) {
440
344
  LinearExpr expr(x);
441
345
  return SolutionIntegerValue(self, expr);
442
346
  })
443
347
  .define_method("solution_boolean_value", &SolutionBooleanValue)
444
348
  .define_method(
445
349
  "status",
446
- *[](CpSolverResponse& self) {
350
+ [](CpSolverResponse& self) {
447
351
  auto status = self.status();
448
352
 
449
353
  if (status == CpSolverStatus::OPTIMAL) {
@@ -462,12 +366,51 @@ void init_constraint(Rice::Module& m) {
462
366
  })
463
367
  .define_method(
464
368
  "sufficient_assumptions_for_infeasibility",
465
- *[](CpSolverResponse& self) {
369
+ [](CpSolverResponse& self) {
466
370
  auto a = Array();
467
371
  auto assumptions = self.sufficient_assumptions_for_infeasibility();
468
- for (auto const& v : assumptions) {
372
+ for (const auto& v : assumptions) {
469
373
  a.push(v);
470
374
  }
471
375
  return a;
472
376
  });
377
+
378
+ Rice::define_class_under(m, "CpSolver")
379
+ .define_method(
380
+ "_solve_with_observer",
381
+ [](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback, bool all_solutions) {
382
+ Model m;
383
+
384
+ if (all_solutions) {
385
+ // set parameters for SearchForAllSolutions
386
+ parameters.set_enumerate_all_solutions(true);
387
+ }
388
+ m.Add(NewSatParameters(parameters));
389
+
390
+ m.Add(NewFeasibleSolutionObserver(
391
+ [callback](const CpSolverResponse& r) {
392
+ // TODO find a better way to do this
393
+ callback.call("response=", r);
394
+ callback.call("on_solution_callback");
395
+ })
396
+ );
397
+ return SolveCpModel(model.Build(), &m);
398
+ })
399
+ .define_method(
400
+ "_solve",
401
+ [](Object self, CpModelBuilder& model, SatParameters& parameters) {
402
+ Model m;
403
+ m.Add(NewSatParameters(parameters));
404
+ return SolveCpModel(model.Build(), &m);
405
+ })
406
+ .define_method(
407
+ "_solution_integer_value",
408
+ [](Object self, CpSolverResponse& response, IntVar& x) {
409
+ return SolutionIntegerValue(response, x);
410
+ })
411
+ .define_method(
412
+ "_solution_boolean_value",
413
+ [](Object self, CpSolverResponse& response, BoolVar& x) {
414
+ return SolutionBooleanValue(response, x);
415
+ });
473
416
  }