PySCIPOpt  4.3.0
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 
139 
140 # local helper functions for the interface
141 cdef Conshdlr getPyConshdlr(SCIP_CONSHDLR* conshdlr):
142  cdef SCIP_CONSHDLRDATA* conshdlrdata
143  conshdlrdata = SCIPconshdlrGetData(conshdlr)
144  return <Conshdlr>conshdlrdata
145 
146 cdef Constraint getPyCons(SCIP_CONS* cons):
147  cdef SCIP_CONSDATA* consdata
148  consdata = SCIPconsGetData(cons)
149  return <Constraint>consdata
150 
151 
152 
153 cdef SCIP_RETCODE PyConshdlrCopy (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) with gil:
154  return SCIP_OKAY
155 
156 cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) with gil:
157  PyConshdlr = getPyConshdlr(conshdlr)
158  PyConshdlr.consfree()
159  Py_DECREF(PyConshdlr)
160  return SCIP_OKAY
161 
162 cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) with gil:
163  PyConshdlr = getPyConshdlr(conshdlr)
164  cdef constraints = []
165  for i in range(nconss):
166  constraints.append(getPyCons(conss[i]))
167  PyConshdlr.consinit(constraints)
168  return SCIP_OKAY
169 
170 cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) with gil:
171  PyConshdlr = getPyConshdlr(conshdlr)
172  cdef constraints = []
173  for i in range(nconss):
174  constraints.append(getPyCons(conss[i]))
175  PyConshdlr.consexit(constraints)
176  return SCIP_OKAY
177 
178 cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) with gil:
179  PyConshdlr = getPyConshdlr(conshdlr)
180  cdef constraints = []
181  for i in range(nconss):
182  constraints.append(getPyCons(conss[i]))
183  PyConshdlr.consinitpre(constraints)
184  return SCIP_OKAY
185 
186 cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) with gil:
187  PyConshdlr = getPyConshdlr(conshdlr)
188  cdef constraints = []
189  for i in range(nconss):
190  constraints.append(getPyCons(conss[i]))
191  PyConshdlr.consexitpre(constraints)
192  return SCIP_OKAY
193 
194 cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) with gil:
195  PyConshdlr = getPyConshdlr(conshdlr)
196  cdef constraints = []
197  for i in range(nconss):
198  constraints.append(getPyCons(conss[i]))
199  PyConshdlr.consinitsol(constraints)
200  return SCIP_OKAY
201 
202 cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) with gil:
203  PyConshdlr = getPyConshdlr(conshdlr)
204  cdef constraints = []
205  for i in range(nconss):
206  constraints.append(getPyCons(conss[i]))
207  PyConshdlr.consexitsol(constraints, restart)
208  return SCIP_OKAY
209 
210 cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) with gil:
211  PyConshdlr = getPyConshdlr(conshdlr)
212  PyCons = getPyCons(cons)
213  assert <Constraint>consdata[0] == PyCons
214  PyConshdlr.consdelete(PyCons)
215  consdata[0] = NULL
216  Py_DECREF(PyCons)
217  return SCIP_OKAY
218 
219 cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) with gil:
220  cdef Constraint PyTargetCons
221  PyConshdlr = getPyConshdlr(conshdlr)
222  PySourceCons = getPyCons(sourcecons)
223  result_dict = PyConshdlr.constrans(PySourceCons)
224 
225  # create target (transform) constraint: if user doesn't return a constraint, copy PySourceCons
226  # otherwise use the created cons
227  if "targetcons" in result_dict:
228  PyTargetCons = result_dict.get("targetcons")
229  targetcons[0] = PyTargetCons.scip_cons
230  Py_INCREF(PyTargetCons)
231  else:
232  PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, <SCIP_CONSDATA*>PySourceCons,
233  PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(),
234  PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(),
235  PySourceCons.isRemovable(), PySourceCons.isStickingAtNode()))
236  return SCIP_OKAY
237 
238 cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) with gil:
239  PyConshdlr = getPyConshdlr(conshdlr)
240  cdef constraints = []
241  for i in range(nconss):
242  constraints.append(getPyCons(conss[i]))
243  result_dict = PyConshdlr.consinitlp(constraints)
244  infeasible[0] = result_dict.get("infeasible", infeasible[0])
245  return SCIP_OKAY
246 
247 cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) with gil:
248  PyConshdlr = getPyConshdlr(conshdlr)
249  cdef constraints = []
250  for i in range(nconss):
251  constraints.append(getPyCons(conss[i]))
252  result_dict = PyConshdlr.conssepalp(constraints, nusefulconss)
253  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
254  return SCIP_OKAY
255 
256 cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
257  SCIP_SOL* sol, SCIP_RESULT* result) with gil:
258  PyConshdlr = getPyConshdlr(conshdlr)
259  cdef constraints = []
260  for i in range(nconss):
261  constraints.append(getPyCons(conss[i]))
262  solution = Solution.create(scip, sol)
263  result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution)
264  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
265  return SCIP_OKAY
266 
267 cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
268  SCIP_Bool solinfeasible, SCIP_RESULT* result) with gil:
269  PyConshdlr = getPyConshdlr(conshdlr)
270  cdef constraints = []
271  for i in range(nconss):
272  constraints.append(getPyCons(conss[i]))
273  result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible)
274  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
275  return SCIP_OKAY
276 
277 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) with gil:
278  PyConshdlr = getPyConshdlr(conshdlr)
279  cdef constraints = []
280  for i in range(nconss):
281  constraints.append(getPyCons(conss[i]))
282  solution = Solution.create(scip, sol)
283  result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible)
284  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
285  return SCIP_OKAY
286 
287 cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
288  SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) with gil:
289  PyConshdlr = getPyConshdlr(conshdlr)
290  cdef constraints = []
291  for i in range(nconss):
292  constraints.append(getPyCons(conss[i]))
293  result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible)
294  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
295  return SCIP_OKAY
296 
297 cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality,
298  SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) with gil:
299  PyConshdlr = getPyConshdlr(conshdlr)
300  cdef constraints = []
301  for i in range(nconss):
302  constraints.append(getPyCons(conss[i]))
303  solution = Solution.create(scip, sol)
304  result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely)
305  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
306  return SCIP_OKAY
307 
308 cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss,
309  SCIP_PROPTIMING proptiming, SCIP_RESULT* result) with gil:
310  PyConshdlr = getPyConshdlr(conshdlr)
311  cdef constraints = []
312  for i in range(nconss):
313  constraints.append(getPyCons(conss[i]))
314  result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming)
315  result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
316  return SCIP_OKAY
317 
318 cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming,
319  int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes,
320  int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides,
321  int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes,
322  int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) with gil:
323  PyConshdlr = getPyConshdlr(conshdlr)
324  cdef constraints = []
325  for i in range(nconss):
326  constraints.append(getPyCons(conss[i]))
327  # dictionary for input/output parameters
328  result_dict = {}
329  result_dict["nfixedvars"] = nfixedvars[0]
330  result_dict["naggrvars"] = naggrvars[0]
331  result_dict["nchgvartypes"] = nchgvartypes[0]
332  result_dict["nchgbds"] = nchgbds[0]
333  result_dict["naddholes"] = naddholes[0]
334  result_dict["ndelconss"] = ndelconss[0]
335  result_dict["naddconss"] = naddconss[0]
336  result_dict["nupgdconss"] = nupgdconss[0]
337  result_dict["nchgcoefs"] = nchgcoefs[0]
338  result_dict["nchgsides"] = nchgsides[0]
339  result_dict["result"] = result[0]
340  PyConshdlr.conspresol(constraints, nrounds, presoltiming,
341  nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
342  nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict)
343  result[0] = result_dict["result"]
344  nfixedvars[0] = result_dict["nfixedvars"]
345  naggrvars[0] = result_dict["naggrvars"]
346  nchgvartypes[0] = result_dict["nchgvartypes"]
347  nchgbds[0] = result_dict["nchgbds"]
348  naddholes[0] = result_dict["naddholes"]
349  ndelconss[0] = result_dict["ndelconss"]
350  naddconss[0] = result_dict["naddconss"]
351  nupgdconss[0] = result_dict["nupgdconss"]
352  nchgcoefs[0] = result_dict["nchgcoefs"]
353  nchgsides[0] = result_dict["nchgsides"]
354  return SCIP_OKAY
355 
356 cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo,
357  SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) with gil:
358  PyConshdlr = getPyConshdlr(conshdlr)
359  PyConshdlr.consresprop()
360  return SCIP_OKAY
361 
362 cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) with gil:
363  PyConshdlr = getPyConshdlr(conshdlr)
364  if cons == NULL:
365  PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg)
366  else:
367  PyCons = getPyCons(cons)
368  PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg)
369  return SCIP_OKAY
370 
371 cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) with gil:
372  PyConshdlr = getPyConshdlr(conshdlr)
373  PyCons = getPyCons(cons)
374  PyConshdlr.consactive(PyCons)
375  return SCIP_OKAY
376 
377 cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) with gil:
378  PyConshdlr = getPyConshdlr(conshdlr)
379  PyCons = getPyCons(cons)
380  PyConshdlr.consdeactive(PyCons)
381  return SCIP_OKAY
382 
383 cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) with gil:
384  PyConshdlr = getPyConshdlr(conshdlr)
385  PyCons = getPyCons(cons)
386  PyConshdlr.consenable(PyCons)
387  return SCIP_OKAY
388 
389 cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) with gil:
390  PyConshdlr = getPyConshdlr(conshdlr)
391  PyCons = getPyCons(cons)
392  PyConshdlr.consdisable(PyCons)
393  return SCIP_OKAY
394 
395 cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) with gil:
396  PyConshdlr = getPyConshdlr(conshdlr)
397  cdef constraints = []
398  for i in range(nconss):
399  constraints.append(getPyCons(conss[i]))
400  PyConshdlr.consdelvars(constraints)
401  return SCIP_OKAY
402 
403 cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) with gil:
404  PyConshdlr = getPyConshdlr(conshdlr)
405  PyCons = getPyCons(cons)
406  # TODO: pass file
407  PyConshdlr.consprint(PyCons)
408  return SCIP_OKAY
409 
410 cdef SCIP_RETCODE PyConsCopy (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr,
411  SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_Bool initial,
412  SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local,
413  SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode,
414  SCIP_Bool isglobal, SCIP_Bool* valid) with gil:
415  # TODO everything!
416  PyConshdlr = getPyConshdlr(sourceconshdlr)
417  PyConshdlr.conscopy()
418  valid[0] = False
419  return SCIP_OKAY
420 
421 cdef SCIP_RETCODE PyConsParse (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str,
422  SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate,
423  SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable,
424  SCIP_Bool stickingatnode, SCIP_Bool* success) with gil:
425  # TODO everything!
426  PyConshdlr = getPyConshdlr(conshdlr)
427  PyConshdlr.consparse()
428  success[0] = False
429  return SCIP_OKAY
430 
431 cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) with gil:
432  # TODO
433  PyConshdlr = getPyConshdlr(conshdlr)
434  PyCons = getPyCons(cons)
435  PyConshdlr.consgetvars(PyCons)
436  success[0] = False
437  return SCIP_OKAY
438 
439 cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) with gil:
440  PyConshdlr = getPyConshdlr(conshdlr)
441  PyCons = getPyCons(cons)
442  result_dict = PyConshdlr.consgetnvars(PyCons)
443  nvars[0] = result_dict.get("nvars", 0)
444  success[0] = result_dict.get("success", False)
445  return SCIP_OKAY
446 
447 cdef SCIP_RETCODE PyConsGetdivebdchgs (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol,
448  SCIP_Bool* success, SCIP_Bool* infeasible) with gil:
449  # TODO
450  PyConshdlr = getPyConshdlr(conshdlr)
451  PyConshdlr.consgetdivebdchgs()
452  success[0] = False
453  infeasible[0] = False
454  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.conssepasol
def conssepasol(self, constraints, nusefulconss, solution)
Definition: conshdlr.pxi:52
pyscipopt.scip.str_conversion
str_conversion
Definition: scip.pyx:46
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.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