PySCIPOpt  5.1.1
Python Interface for the SCIP Optimization Suite
conshdlr.pxi
Go to the documentation of this file.
1 
3 
4 cdef class Conshdlr:
5  cdef public Model model
6  cdef public str name
7 
8  def consfree(self):
9  '''calls destructor and frees memory of constraint handler '''
10  pass
11 
12  def consinit(self, constraints):
13  '''calls initialization method of constraint handler '''
14  pass
15 
16  def consexit(self, constraints):
17  '''calls exit method of constraint handler '''
18  pass
19 
20  def consinitpre(self, constraints):
21  '''informs constraint handler that the presolving process is being started '''
22  pass
23 
24  def consexitpre(self, constraints):
25  '''informs constraint handler that the presolving is finished '''
26  pass
27 
28  def consinitsol(self, constraints):
29  '''informs constraint handler that the branch and bound process is being started '''
30  pass
31 
32  def consexitsol(self, constraints, restart):
33  '''informs constraint handler that the branch and bound process data is being freed '''
34  pass
35 
36  def consdelete(self, constraint):
37  '''sets method of constraint handler to free specific constraint data '''
38  pass
39 
40  def constrans(self, sourceconstraint):
41  '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem '''
42  return {}
43 
44  def consinitlp(self, constraints):
45  '''calls LP initialization method of constraint handler to separate all initial active constraints '''
46  return {}
47 
48  def conssepalp(self, constraints, nusefulconss):
49  '''calls separator method of constraint handler to separate LP solution '''
50  return {}
51 
52  def conssepasol(self, constraints, nusefulconss, solution):
53  '''calls separator method of constraint handler to separate given primal solution '''
54  return {}
55 
56  def consenfolp(self, constraints, nusefulconss, solinfeasible):
57  '''calls enforcing method of constraint handler for LP solution for all constraints added'''
58  print("python error in consenfolp: this method needs to be implemented")
59  return {}
60 
61  def consenforelax(self, solution, constraints, nusefulconss, solinfeasible):
62  '''calls enforcing method of constraint handler for a relaxation solution for all constraints added'''
63  print("python error in consenforelax: this method needs to be implemented")
64  return {}
65 
66  def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible):
67  '''calls enforcing method of constraint handler for pseudo solution for all constraints added'''
68  print("python error in consenfops: this method needs to be implemented")
69  return {}
70 
71  def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely):
72  '''calls feasibility check method of constraint handler '''
73  print("python error in conscheck: this method needs to be implemented")
74  return {}
75 
76  def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming):
77  '''calls propagation method of constraint handler '''
78  return {}
79 
80  def conspresol(self, constraints, nrounds, presoltiming,
81  nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
82  nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict):
83  '''calls presolving method of constraint handler '''
84  return result_dict
85 
86  def consresprop(self):
87  '''sets propagation conflict resolving method of constraint handler '''
88  return {}
89 
90  def conslock(self, constraint, locktype, nlockspos, nlocksneg):
91  '''variable rounding lock method of constraint handler'''
92  print("python error in conslock: this method needs to be implemented")
93  return {}
94 
95  def consactive(self, constraint):
96  '''sets activation notification method of constraint handler '''
97  pass
98 
99  def consdeactive(self, constraint):
100  '''sets deactivation notification method of constraint handler '''
101  pass
102 
103  def consenable(self, constraint):
104  '''sets enabling notification method of constraint handler '''
105  pass
106 
107  def consdisable(self, constraint):
108  '''sets disabling notification method of constraint handler '''
109  pass
110 
111  def consdelvars(self, constraints):
112  '''calls variable deletion method of constraint handler'''
113  pass
114 
115  def consprint(self, constraint):
116  '''sets constraint display method of constraint handler '''
117  pass
118 
119  def conscopy(self):
120  '''sets copy method of both the constraint handler and each associated constraint'''
121  pass
122 
123  def consparse(self):
124  '''sets constraint parsing method of constraint handler '''
125  pass
126 
127  def consgetvars(self, constraint):
128  '''sets constraint variable getter method of constraint handler'''
129  pass
130 
131  def consgetnvars(self, constraint):
132  '''sets constraint variable number getter method of constraint handler '''
133  return {}
134 
135  def consgetdivebdchgs(self):
136  '''calls diving solution enforcement callback of constraint handler, if it exists '''
137  pass
138 
140  '''permutation symmetry detection graph getter callback, if it exists '''
141  pass
142 
144  '''signed permutation symmetry detection graph getter callback, if it exists '''
145  pass
146 
147 
148 # local helper functions for the interface
149 cdef Conshdlr getPyConshdlr(SCIP_CONSHDLR* conshdlr):
150  cdef SCIP_CONSHDLRDATA* conshdlrdata
151  conshdlrdata = SCIPconshdlrGetData(conshdlr)
152  return <Conshdlr>conshdlrdata
153 
154 cdef Constraint getPyCons(SCIP_CONS* cons):
155  cdef SCIP_CONSDATA* consdata
156  consdata = SCIPconsGetData(cons)
157  return <Constraint>consdata
158 
159 
160 
161 cdef SCIP_RETCODE PyConshdlrCopy (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) noexcept with gil:
162  return SCIP_OKAY
163 
164 cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil:
165  PyConshdlr = getPyConshdlr(conshdlr)
166  PyConshdlr.consfree()
167  Py_DECREF(PyConshdlr)
168  return SCIP_OKAY
169 
170 cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
171  PyConshdlr = getPyConshdlr(conshdlr)
172  cdef constraints = []
173  for i in range(nconss):
174  constraints.append(getPyCons(conss[i]))
175  PyConshdlr.consinit(constraints)
176  return SCIP_OKAY
177 
178 cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
179  PyConshdlr = getPyConshdlr(conshdlr)
180  cdef constraints = []
181  for i in range(nconss):
182  constraints.append(getPyCons(conss[i]))
183  PyConshdlr.consexit(constraints)
184  return SCIP_OKAY
185 
186 cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
187  PyConshdlr = getPyConshdlr(conshdlr)
188  cdef constraints = []
189  for i in range(nconss):
190  constraints.append(getPyCons(conss[i]))
191  PyConshdlr.consinitpre(constraints)
192  return SCIP_OKAY
193 
194 cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
195  PyConshdlr = getPyConshdlr(conshdlr)
196  cdef constraints = []
197  for i in range(nconss):
198  constraints.append(getPyCons(conss[i]))
199  PyConshdlr.consexitpre(constraints)
200  return SCIP_OKAY
201 
202 cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
203  PyConshdlr = getPyConshdlr(conshdlr)
204  cdef constraints = []
205  for i in range(nconss):
206  constraints.append(getPyCons(conss[i]))
207  PyConshdlr.consinitsol(constraints)
208  return SCIP_OKAY
209 
210 cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil:
211  PyConshdlr = getPyConshdlr(conshdlr)
212  cdef constraints = []
213  for i in range(nconss):
214  constraints.append(getPyCons(conss[i]))
215  PyConshdlr.consexitsol(constraints, restart)
216  return SCIP_OKAY
217 
218 cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil:
219  PyConshdlr = getPyConshdlr(conshdlr)
220  PyCons = getPyCons(cons)
221  assert <Constraint>consdata[0] == PyCons
222  PyConshdlr.consdelete(PyCons)
223  consdata[0] = NULL
224  Py_DECREF(PyCons)
225  return SCIP_OKAY
226 
227 cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) noexcept with gil:
228  cdef Constraint PyTargetCons
229  PyConshdlr = getPyConshdlr(conshdlr)
230  PySourceCons = getPyCons(sourcecons)
231  result_dict = PyConshdlr.constrans(PySourceCons)
232 
233  # create target (transform) constraint: if user doesn't return a constraint, copy PySourceCons
234  # otherwise use the created cons
235  if "targetcons" in result_dict:
236  PyTargetCons = result_dict.get("targetcons")
237  targetcons[0] = PyTargetCons.scip_cons
238  Py_INCREF(PyTargetCons)
239  else:
240  PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, <SCIP_CONSDATA*>PySourceCons,
241  PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(),
242  PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(),
243  PySourceCons.isRemovable(), PySourceCons.isStickingAtNode()))
244  return SCIP_OKAY
245 
246 cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil:
247  PyConshdlr = getPyConshdlr(conshdlr)
248  cdef constraints = []
249  for i in range(nconss):
250  constraints.append(getPyCons(conss[i]))
251  result_dict = PyConshdlr.consinitlp(constraints)
252  infeasible[0] = result_dict.get("infeasible", infeasible[0])
253  return SCIP_OKAY
254 
255 cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil:
256  PyConshdlr = getPyConshdlr(conshdlr)
257  cdef constraints = []
258  for i in range(nconss):
259  constraints.append(getPyCons(conss[i]))
260  result_dict = PyConshdlr.conssepalp(constraints, nusefulconss)
261  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
262  return SCIP_OKAY
263 
264 cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
265  SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil:
266  PyConshdlr = getPyConshdlr(conshdlr)
267  cdef constraints = []
268  for i in range(nconss):
269  constraints.append(getPyCons(conss[i]))
270  solution = Solution.create(scip, sol)
271  result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution)
272  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
273  return SCIP_OKAY
274 
275 cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
276  SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil:
277  PyConshdlr = getPyConshdlr(conshdlr)
278  cdef constraints = []
279  for i in range(nconss):
280  constraints.append(getPyCons(conss[i]))
281  result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible)
282  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
283  return SCIP_OKAY
284 
285 cdef SCIP_RETCODE PyConsEnforelax (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil:
286  PyConshdlr = getPyConshdlr(conshdlr)
287  cdef constraints = []
288  for i in range(nconss):
289  constraints.append(getPyCons(conss[i]))
290  solution = Solution.create(scip, sol)
291  result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible)
292  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
293  return SCIP_OKAY
294 
295 cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
296  SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil:
297  PyConshdlr = getPyConshdlr(conshdlr)
298  cdef constraints = []
299  for i in range(nconss):
300  constraints.append(getPyCons(conss[i]))
301  result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible)
302  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
303  return SCIP_OKAY
304 
305 cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality,
306  SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil:
307  PyConshdlr = getPyConshdlr(conshdlr)
308  cdef constraints = []
309  for i in range(nconss):
310  constraints.append(getPyCons(conss[i]))
311  solution = Solution.create(scip, sol)
312  result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely)
313  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
314  return SCIP_OKAY
315 
316 cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss,
317  SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil:
318  PyConshdlr = getPyConshdlr(conshdlr)
319  cdef constraints = []
320  for i in range(nconss):
321  constraints.append(getPyCons(conss[i]))
322  result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming)
323  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
324  return SCIP_OKAY
325 
326 cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming,
327  int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes,
328  int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides,
329  int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes,
330  int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil:
331  PyConshdlr = getPyConshdlr(conshdlr)
332  cdef constraints = []
333  for i in range(nconss):
334  constraints.append(getPyCons(conss[i]))
335  # dictionary for input/output parameters
336  result_dict = {}
337  result_dict["nfixedvars"] = nfixedvars[0]
338  result_dict["naggrvars"] = naggrvars[0]
339  result_dict["nchgvartypes"] = nchgvartypes[0]
340  result_dict["nchgbds"] = nchgbds[0]
341  result_dict["naddholes"] = naddholes[0]
342  result_dict["ndelconss"] = ndelconss[0]
343  result_dict["naddconss"] = naddconss[0]
344  result_dict["nupgdconss"] = nupgdconss[0]
345  result_dict["nchgcoefs"] = nchgcoefs[0]
346  result_dict["nchgsides"] = nchgsides[0]
347  result_dict["result"] = result[0]
348  PyConshdlr.conspresol(constraints, nrounds, presoltiming,
349  nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
350  nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict)
351  result[0] = result_dict["result"]
352  nfixedvars[0] = result_dict["nfixedvars"]
353  naggrvars[0] = result_dict["naggrvars"]
354  nchgvartypes[0] = result_dict["nchgvartypes"]
355  nchgbds[0] = result_dict["nchgbds"]
356  naddholes[0] = result_dict["naddholes"]
357  ndelconss[0] = result_dict["ndelconss"]
358  naddconss[0] = result_dict["naddconss"]
359  nupgdconss[0] = result_dict["nupgdconss"]
360  nchgcoefs[0] = result_dict["nchgcoefs"]
361  nchgsides[0] = result_dict["nchgsides"]
362  return SCIP_OKAY
363 
364 cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo,
365  SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil:
366  PyConshdlr = getPyConshdlr(conshdlr)
367  PyConshdlr.consresprop()
368  return SCIP_OKAY
369 
370 cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil:
371  PyConshdlr = getPyConshdlr(conshdlr)
372  if cons == NULL:
373  PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg)
374  else:
375  PyCons = getPyCons(cons)
376  PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg)
377  return SCIP_OKAY
378 
379 cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil:
380  PyConshdlr = getPyConshdlr(conshdlr)
381  PyCons = getPyCons(cons)
382  PyConshdlr.consactive(PyCons)
383  return SCIP_OKAY
384 
385 cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil:
386  PyConshdlr = getPyConshdlr(conshdlr)
387  PyCons = getPyCons(cons)
388  PyConshdlr.consdeactive(PyCons)
389  return SCIP_OKAY
390 
391 cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil:
392  PyConshdlr = getPyConshdlr(conshdlr)
393  PyCons = getPyCons(cons)
394  PyConshdlr.consenable(PyCons)
395  return SCIP_OKAY
396 
397 cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil:
398  PyConshdlr = getPyConshdlr(conshdlr)
399  PyCons = getPyCons(cons)
400  PyConshdlr.consdisable(PyCons)
401  return SCIP_OKAY
402 
403 cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
404  PyConshdlr = getPyConshdlr(conshdlr)
405  cdef constraints = []
406  for i in range(nconss):
407  constraints.append(getPyCons(conss[i]))
408  PyConshdlr.consdelvars(constraints)
409  return SCIP_OKAY
410 
411 cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil:
412  PyConshdlr = getPyConshdlr(conshdlr)
413  PyCons = getPyCons(cons)
414  # TODO: pass file
415  PyConshdlr.consprint(PyCons)
416  return SCIP_OKAY
417 
418 cdef SCIP_RETCODE PyConsCopy (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr,
419  SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_Bool initial,
420  SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local,
421  SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode,
422  SCIP_Bool isglobal, SCIP_Bool* valid) noexcept with gil:
423  # TODO everything!
424  PyConshdlr = getPyConshdlr(sourceconshdlr)
425  PyConshdlr.conscopy()
426  valid[0] = False
427  return SCIP_OKAY
428 
429 cdef SCIP_RETCODE PyConsParse (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str,
430  SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate,
431  SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable,
432  SCIP_Bool stickingatnode, SCIP_Bool* success) noexcept with gil:
433  # TODO everything!
434  PyConshdlr = getPyConshdlr(conshdlr)
435  PyConshdlr.consparse()
436  success[0] = False
437  return SCIP_OKAY
438 
439 cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) noexcept with gil:
440  # TODO
441  PyConshdlr = getPyConshdlr(conshdlr)
442  PyCons = getPyCons(cons)
443  PyConshdlr.consgetvars(PyCons)
444  success[0] = False
445  return SCIP_OKAY
446 
447 cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil:
448  PyConshdlr = getPyConshdlr(conshdlr)
449  PyCons = getPyCons(cons)
450  result_dict = PyConshdlr.consgetnvars(PyCons)
451  nvars[0] = result_dict.get("nvars", 0)
452  success[0] = result_dict.get("success", False)
453  return SCIP_OKAY
454 
455 cdef SCIP_RETCODE PyConsGetdivebdchgs (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol,
456  SCIP_Bool* success, SCIP_Bool* infeasible) noexcept with gil:
457  # TODO
458  PyConshdlr = getPyConshdlr(conshdlr)
459  PyConshdlr.consgetdivebdchgs()
460  success[0] = False
461  infeasible[0] = False
462  return SCIP_OKAY
463 
464 cdef SCIP_RETCODE PyConsGetPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph,
465  SCIP_Bool* success) noexcept with gil:
466  # TODO
467  PyConshdlr = getPyConshdlr(conshdlr)
468  PyConshdlr.consgetpermsymgraph()
469  success[0] = False
470  return SCIP_OKAY
471 
472 cdef SCIP_RETCODE PyConsGetSignedPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph,
473  SCIP_Bool* success) noexcept with gil:
474  # TODO
475  PyConshdlr = getPyConshdlr(conshdlr)
476  PyConshdlr.consgetsignedpermsymgraph()
477  success[0] = False
478  return SCIP_OKAY
pyscipopt.conshdlr.consinitsol
def consinitsol(self, constraints)
Definition: conshdlr.pxi:28
pyscipopt.conshdlr.consexitpre
def consexitpre(self, constraints)
Definition: conshdlr.pxi:24
pyscipopt.conshdlr.consdelvars
def consdelvars(self, constraints)
Definition: conshdlr.pxi:111
pyscipopt.conshdlr.conspresol
def conspresol(self, constraints, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict)
Definition: conshdlr.pxi:80
pyscipopt.conshdlr.consenforelax
def consenforelax(self, solution, constraints, nusefulconss, solinfeasible)
Definition: conshdlr.pxi:61
pyscipopt.conshdlr.consgetdivebdchgs
def consgetdivebdchgs(self)
Definition: conshdlr.pxi:135
pyscipopt.conshdlr.consresprop
def consresprop(self)
Definition: conshdlr.pxi:86
pyscipopt.conshdlr.consparse
def consparse(self)
Definition: conshdlr.pxi:123
pyscipopt.conshdlr.consinitlp
def consinitlp(self, constraints)
Definition: conshdlr.pxi:44
pyscipopt.conshdlr.consgetsignedpermsymgraph
def consgetsignedpermsymgraph(self)
Definition: conshdlr.pxi:143
pyscipopt.conshdlr.conssepasol
def conssepasol(self, constraints, nusefulconss, solution)
Definition: conshdlr.pxi:52
pyscipopt.scip.str_conversion
str_conversion
Definition: scip.pxi:48
SCIPcreateCons
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
pyscipopt.conshdlr.consdelete
def consdelete(self, constraint)
Definition: conshdlr.pxi:36
pyscipopt.conshdlr.consexitsol
def consexitsol(self, constraints, restart)
Definition: conshdlr.pxi:32
pyscipopt.conshdlr.consactive
def consactive(self, constraint)
Definition: conshdlr.pxi:95
pyscipopt.conshdlr.consenable
def consenable(self, constraint)
Definition: conshdlr.pxi:103
pyscipopt.conshdlr.conssepalp
def conssepalp(self, constraints, nusefulconss)
Definition: conshdlr.pxi:48
pyscipopt.conshdlr.conslock
def conslock(self, constraint, locktype, nlockspos, nlocksneg)
Definition: conshdlr.pxi:90
pyscipopt.conshdlr.consgetpermsymgraph
def consgetpermsymgraph(self)
Definition: conshdlr.pxi:139
pyscipopt.conshdlr.consdisable
def consdisable(self, constraint)
Definition: conshdlr.pxi:107
pyscipopt.conshdlr.constrans
def constrans(self, sourceconstraint)
Definition: conshdlr.pxi:40
pyscipopt.conshdlr.consenfops
def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible)
Definition: conshdlr.pxi:66
pyscipopt.conshdlr.consgetnvars
def consgetnvars(self, constraint)
Definition: conshdlr.pxi:131
pyscipopt.conshdlr.consdeactive
def consdeactive(self, constraint)
Definition: conshdlr.pxi:99
pyscipopt.conshdlr.conscheck
def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely)
Definition: conshdlr.pxi:71
pyscipopt.conshdlr.consenfolp
def consenfolp(self, constraints, nusefulconss, solinfeasible)
Definition: conshdlr.pxi:56
pyscipopt.conshdlr.consinit
def consinit(self, constraints)
Definition: conshdlr.pxi:12
pyscipopt.conshdlr.consfree
def consfree(self)
Definition: conshdlr.pxi:8
pyscipopt.conshdlr.consprint
def consprint(self, constraint)
Definition: conshdlr.pxi:115
SCIPconshdlrGetData
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
pyscipopt.conshdlr.consinitpre
def consinitpre(self, constraints)
Definition: conshdlr.pxi:20
pyscipopt.conshdlr.consprop
def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming)
Definition: conshdlr.pxi:76
pyscipopt.conshdlr.consexit
def consexit(self, constraints)
Definition: conshdlr.pxi:16
pyscipopt.conshdlr.conscopy
def conscopy(self)
Definition: conshdlr.pxi:119
pyscipopt.conshdlr.consgetvars
def consgetvars(self, constraint)
Definition: conshdlr.pxi:127
SCIPconsGetData
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
pyscipopt.conshdlr.Conshdlr
Definition: conshdlr.pxi:4